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 |
|---|---|---|---|---|---|
Provide tags and a correct Python 3 solution for this coding contest problem.
Some people leave the lights at their workplaces on when they leave that is a waste of resources. As a hausmeister of DHBW, Sagheer waits till all students and professors leave the university building, then goes and turns all the lights off.
The building consists of n floors with stairs at the left and the right sides. Each floor has m rooms on the same line with a corridor that connects the left and right stairs passing by all the rooms. In other words, the building can be represented as a rectangle with n rows and m + 2 columns, where the first and the last columns represent the stairs, and the m columns in the middle represent rooms.
Sagheer is standing at the ground floor at the left stairs. He wants to turn all the lights off in such a way that he will not go upstairs until all lights in the floor he is standing at are off. Of course, Sagheer must visit a room to turn the light there off. It takes one minute for Sagheer to go to the next floor using stairs or to move from the current room/stairs to a neighboring room/stairs on the same floor. It takes no time for him to switch the light off in the room he is currently standing in. Help Sagheer find the minimum total time to turn off all the lights.
Note that Sagheer does not have to go back to his starting position, and he does not have to visit rooms where the light is already switched off.
Input
The first line contains two integers n and m (1 ≤ n ≤ 15 and 1 ≤ m ≤ 100) — the number of floors and the number of rooms in each floor, respectively.
The next n lines contains the building description. Each line contains a binary string of length m + 2 representing a floor (the left stairs, then m rooms, then the right stairs) where 0 indicates that the light is off and 1 indicates that the light is on. The floors are listed from top to bottom, so that the last line represents the ground floor.
The first and last characters of each string represent the left and the right stairs, respectively, so they are always 0.
Output
Print a single integer — the minimum total time needed to turn off all the lights.
Examples
Input
2 2
0010
0100
Output
5
Input
3 4
001000
000010
000010
Output
12
Input
4 3
01110
01110
01110
01110
Output
18
Note
In the first example, Sagheer will go to room 1 in the ground floor, then he will go to room 2 in the second floor using the left or right stairs.
In the second example, he will go to the fourth room in the ground floor, use right stairs, go to the fourth room in the second floor, use right stairs again, then go to the second room in the last floor.
In the third example, he will walk through the whole corridor alternating between the left and right stairs at each floor. | instruction | 0 | 68,618 | 8 | 137,236 |
Tags: bitmasks, brute force, dp
Correct Solution:
```
from itertools import dropwhile
n, m = map(int, input().split())
m += 2
p = list(dropwhile(lambda line: '1' not in line, (input() for i in range(n))))
p.reverse()
addition = len(p) - 1
p = list(filter(lambda line: '1' in line, p))
n = len(p)
if n == 0:
print(0)
exit(0)
left = [line.find('1') for line in p]
right = [line.rfind('1') for line in p]
ans = float('inf')
for mask in range(2 ** n):
cur_res = 0
prev = 1
for i in range(n):
go_left = mask & (1 << i)
if go_left and prev:
cur_res += 2 * right[i]
elif (go_left and not prev) or (not go_left and prev):
cur_res += m - 1
elif not go_left and not go_left:
cur_res += 2 * (m - 1 - left[i])
if i == n - 1:
if go_left and prev:
cur_res -= right[i]
elif not go_left and not prev:
cur_res -= m - 1 - left[i]
elif go_left and not prev:
cur_res -= left[i]
elif not go_left and prev:
cur_res -= m - 1 - right[i]
prev = go_left
ans = min(ans, cur_res)
print(ans + addition)
``` | output | 1 | 68,618 | 8 | 137,237 |
Provide tags and a correct Python 3 solution for this coding contest problem.
Some people leave the lights at their workplaces on when they leave that is a waste of resources. As a hausmeister of DHBW, Sagheer waits till all students and professors leave the university building, then goes and turns all the lights off.
The building consists of n floors with stairs at the left and the right sides. Each floor has m rooms on the same line with a corridor that connects the left and right stairs passing by all the rooms. In other words, the building can be represented as a rectangle with n rows and m + 2 columns, where the first and the last columns represent the stairs, and the m columns in the middle represent rooms.
Sagheer is standing at the ground floor at the left stairs. He wants to turn all the lights off in such a way that he will not go upstairs until all lights in the floor he is standing at are off. Of course, Sagheer must visit a room to turn the light there off. It takes one minute for Sagheer to go to the next floor using stairs or to move from the current room/stairs to a neighboring room/stairs on the same floor. It takes no time for him to switch the light off in the room he is currently standing in. Help Sagheer find the minimum total time to turn off all the lights.
Note that Sagheer does not have to go back to his starting position, and he does not have to visit rooms where the light is already switched off.
Input
The first line contains two integers n and m (1 ≤ n ≤ 15 and 1 ≤ m ≤ 100) — the number of floors and the number of rooms in each floor, respectively.
The next n lines contains the building description. Each line contains a binary string of length m + 2 representing a floor (the left stairs, then m rooms, then the right stairs) where 0 indicates that the light is off and 1 indicates that the light is on. The floors are listed from top to bottom, so that the last line represents the ground floor.
The first and last characters of each string represent the left and the right stairs, respectively, so they are always 0.
Output
Print a single integer — the minimum total time needed to turn off all the lights.
Examples
Input
2 2
0010
0100
Output
5
Input
3 4
001000
000010
000010
Output
12
Input
4 3
01110
01110
01110
01110
Output
18
Note
In the first example, Sagheer will go to room 1 in the ground floor, then he will go to room 2 in the second floor using the left or right stairs.
In the second example, he will go to the fourth room in the ground floor, use right stairs, go to the fourth room in the second floor, use right stairs again, then go to the second room in the last floor.
In the third example, he will walk through the whole corridor alternating between the left and right stairs at each floor. | instruction | 0 | 68,619 | 8 | 137,238 |
Tags: bitmasks, brute force, dp
Correct Solution:
```
R = lambda: map(int, input().split())
n, m = R()
m += 2
fls = [input() for i in range(n)]
while fls and not fls[0].count('1'):
fls.pop(0)
if not fls:
print(0)
exit(0)
ls, rs = [], []
resv = 0
for i in range(len(fls) - 1, -1, -1):
s = fls[i]
if '1' in s:
ls.append(s.rfind('1'))
rs.append(m - s.find('1') - 1)
else:
resv += 1
n = len(ls)
dp = [[0, 0] for i in range(n)]
dp[0][0] = ls[0]
dp[0][1] = m + rs[0]
for i in range(1, n):
dp[i][0] = min(dp[i - 1][0] + ls[i - 1], dp[i - 1][1] + m - rs[i - 1] - 1) + 1 + ls[i]
dp[i][1] = min(dp[i - 1][0] + m - ls[i - 1] - 1, dp[i - 1][1] + rs[i - 1]) + 1 + rs[i]
print(min(dp[-1]) + resv)
``` | output | 1 | 68,619 | 8 | 137,239 |
Provide tags and a correct Python 3 solution for this coding contest problem.
Some people leave the lights at their workplaces on when they leave that is a waste of resources. As a hausmeister of DHBW, Sagheer waits till all students and professors leave the university building, then goes and turns all the lights off.
The building consists of n floors with stairs at the left and the right sides. Each floor has m rooms on the same line with a corridor that connects the left and right stairs passing by all the rooms. In other words, the building can be represented as a rectangle with n rows and m + 2 columns, where the first and the last columns represent the stairs, and the m columns in the middle represent rooms.
Sagheer is standing at the ground floor at the left stairs. He wants to turn all the lights off in such a way that he will not go upstairs until all lights in the floor he is standing at are off. Of course, Sagheer must visit a room to turn the light there off. It takes one minute for Sagheer to go to the next floor using stairs or to move from the current room/stairs to a neighboring room/stairs on the same floor. It takes no time for him to switch the light off in the room he is currently standing in. Help Sagheer find the minimum total time to turn off all the lights.
Note that Sagheer does not have to go back to his starting position, and he does not have to visit rooms where the light is already switched off.
Input
The first line contains two integers n and m (1 ≤ n ≤ 15 and 1 ≤ m ≤ 100) — the number of floors and the number of rooms in each floor, respectively.
The next n lines contains the building description. Each line contains a binary string of length m + 2 representing a floor (the left stairs, then m rooms, then the right stairs) where 0 indicates that the light is off and 1 indicates that the light is on. The floors are listed from top to bottom, so that the last line represents the ground floor.
The first and last characters of each string represent the left and the right stairs, respectively, so they are always 0.
Output
Print a single integer — the minimum total time needed to turn off all the lights.
Examples
Input
2 2
0010
0100
Output
5
Input
3 4
001000
000010
000010
Output
12
Input
4 3
01110
01110
01110
01110
Output
18
Note
In the first example, Sagheer will go to room 1 in the ground floor, then he will go to room 2 in the second floor using the left or right stairs.
In the second example, he will go to the fourth room in the ground floor, use right stairs, go to the fourth room in the second floor, use right stairs again, then go to the second room in the last floor.
In the third example, he will walk through the whole corridor alternating between the left and right stairs at each floor. | instruction | 0 | 68,620 | 8 | 137,240 |
Tags: bitmasks, brute force, dp
Correct Solution:
```
n,m=map(int,input().split())
p=1
l=[[1,0]]
l1=[]
r=0
M=[input() for i in range(n)]
for i in range(n) :
if M[i].count('1')==0 :
r=r+1
else :
break
for i in range(n-1,r,-1) :
for j in range(len(l)) :
k=l[j][1]
if l[j][0]==1 :
l1.append([2,k+m+2])
if M[i].count('1')==0 :
l1.append([1,k+1])
else :
l1.append([1,k+(M[i].rindex('1')*2)+1])
else :
l1.append([1,k+m+2])
if M[i].count('1')==0 :
l1.append([2,k+1])
else :
l1.append([2,k+(abs(M[i].index('1')-m-1)*2)+1])
l=l1
l1=[]
min=1000000000
if r==n :
print(0)
exit()
for j in range(len(l)) :
if l[j][0]==1 :
if l[j][1]+M[r].rindex('1')<=min :
min=l[j][1]+M[r].rindex('1')
else :
if l[j][1]+abs(M[r].index('1')-m-1)<=min :
min=l[j][1]+abs(M[r].index('1')-m-1)
print(min)
``` | output | 1 | 68,620 | 8 | 137,241 |
Provide tags and a correct Python 3 solution for this coding contest problem.
Some people leave the lights at their workplaces on when they leave that is a waste of resources. As a hausmeister of DHBW, Sagheer waits till all students and professors leave the university building, then goes and turns all the lights off.
The building consists of n floors with stairs at the left and the right sides. Each floor has m rooms on the same line with a corridor that connects the left and right stairs passing by all the rooms. In other words, the building can be represented as a rectangle with n rows and m + 2 columns, where the first and the last columns represent the stairs, and the m columns in the middle represent rooms.
Sagheer is standing at the ground floor at the left stairs. He wants to turn all the lights off in such a way that he will not go upstairs until all lights in the floor he is standing at are off. Of course, Sagheer must visit a room to turn the light there off. It takes one minute for Sagheer to go to the next floor using stairs or to move from the current room/stairs to a neighboring room/stairs on the same floor. It takes no time for him to switch the light off in the room he is currently standing in. Help Sagheer find the minimum total time to turn off all the lights.
Note that Sagheer does not have to go back to his starting position, and he does not have to visit rooms where the light is already switched off.
Input
The first line contains two integers n and m (1 ≤ n ≤ 15 and 1 ≤ m ≤ 100) — the number of floors and the number of rooms in each floor, respectively.
The next n lines contains the building description. Each line contains a binary string of length m + 2 representing a floor (the left stairs, then m rooms, then the right stairs) where 0 indicates that the light is off and 1 indicates that the light is on. The floors are listed from top to bottom, so that the last line represents the ground floor.
The first and last characters of each string represent the left and the right stairs, respectively, so they are always 0.
Output
Print a single integer — the minimum total time needed to turn off all the lights.
Examples
Input
2 2
0010
0100
Output
5
Input
3 4
001000
000010
000010
Output
12
Input
4 3
01110
01110
01110
01110
Output
18
Note
In the first example, Sagheer will go to room 1 in the ground floor, then he will go to room 2 in the second floor using the left or right stairs.
In the second example, he will go to the fourth room in the ground floor, use right stairs, go to the fourth room in the second floor, use right stairs again, then go to the second room in the last floor.
In the third example, he will walk through the whole corridor alternating between the left and right stairs at each floor. | instruction | 0 | 68,621 | 8 | 137,242 |
Tags: bitmasks, brute force, dp
Correct Solution:
```
n,m=map(int,input().strip().split())
a=[]
L=[]
R=[]
t={}
for i in range(n):
b=input()
a.append(b)
L.append(9000000)
R.append(0)
t[i]=0
a.reverse()
for i in range(n):
for j in range(m+2):
if a[i][j]=='1':
L[i]=min(L[i],j)
R[i]=max(R[i],j)
t[i]=1
L1=0
R1=9000000
ans=0
for i in range(n):
if t[i]==0:
L1+=1
R1+=1
continue
ans=min(L1+R[i],R1+m+1-L[i])
L2=min(L1+R[i]*2+1,R1+m+2)
R2=min(R1+(m+1-L[i])*2+1,m+2+L1)
L1=L2
R1=R2
print(ans)
``` | output | 1 | 68,621 | 8 | 137,243 |
Provide tags and a correct Python 3 solution for this coding contest problem.
Some people leave the lights at their workplaces on when they leave that is a waste of resources. As a hausmeister of DHBW, Sagheer waits till all students and professors leave the university building, then goes and turns all the lights off.
The building consists of n floors with stairs at the left and the right sides. Each floor has m rooms on the same line with a corridor that connects the left and right stairs passing by all the rooms. In other words, the building can be represented as a rectangle with n rows and m + 2 columns, where the first and the last columns represent the stairs, and the m columns in the middle represent rooms.
Sagheer is standing at the ground floor at the left stairs. He wants to turn all the lights off in such a way that he will not go upstairs until all lights in the floor he is standing at are off. Of course, Sagheer must visit a room to turn the light there off. It takes one minute for Sagheer to go to the next floor using stairs or to move from the current room/stairs to a neighboring room/stairs on the same floor. It takes no time for him to switch the light off in the room he is currently standing in. Help Sagheer find the minimum total time to turn off all the lights.
Note that Sagheer does not have to go back to his starting position, and he does not have to visit rooms where the light is already switched off.
Input
The first line contains two integers n and m (1 ≤ n ≤ 15 and 1 ≤ m ≤ 100) — the number of floors and the number of rooms in each floor, respectively.
The next n lines contains the building description. Each line contains a binary string of length m + 2 representing a floor (the left stairs, then m rooms, then the right stairs) where 0 indicates that the light is off and 1 indicates that the light is on. The floors are listed from top to bottom, so that the last line represents the ground floor.
The first and last characters of each string represent the left and the right stairs, respectively, so they are always 0.
Output
Print a single integer — the minimum total time needed to turn off all the lights.
Examples
Input
2 2
0010
0100
Output
5
Input
3 4
001000
000010
000010
Output
12
Input
4 3
01110
01110
01110
01110
Output
18
Note
In the first example, Sagheer will go to room 1 in the ground floor, then he will go to room 2 in the second floor using the left or right stairs.
In the second example, he will go to the fourth room in the ground floor, use right stairs, go to the fourth room in the second floor, use right stairs again, then go to the second room in the last floor.
In the third example, he will walk through the whole corridor alternating between the left and right stairs at each floor. | instruction | 0 | 68,622 | 8 | 137,244 |
Tags: bitmasks, brute force, dp
Correct Solution:
```
def simulate(n, m, first, last, mask):
pos = 'left'
time = 0
for floor in range(n - 1):
action = mask & 1
mask >>= 1
if pos == 'left':
if action == 0:
time += 2 * last[floor]
else:
time += m + 1
pos = 'right'
else:
if action == 0:
time += 2 * (m + 1 - first[floor])
else:
time += m + 1
pos = 'left'
time += 1
if pos == 'left':
time += last[n - 1]
else:
time += m + 1 - first[n - 1]
return time
def main():
n, m = map(int, input().split())
building = []
for i in range(n):
building.append(list(map(int, input())))
i_max = None
for i in range(n):
if any(x == 1 for x in building[i]):
i_max = i
break
if i_max is None:
i_max = n
n = n - i_max
if n == 0:
print(0)
return
building = building[::-1]
building = building[:n]
first = [m + 1] * n
last = [0] * n
for i in range(n):
for j in range(m + 2):
if building[i][j] == 1:
if first[i] == m + 1:
first[i] = j
last[i] = j
min_time = 10 * ((m + 1) * n + n)
for mask in range(2 ** (n - 1)):
min_time = min(min_time, simulate(n, m, first, last, mask))
print(min_time)
if __name__ == '__main__':
main()
``` | output | 1 | 68,622 | 8 | 137,245 |
Provide tags and a correct Python 3 solution for this coding contest problem.
Some people leave the lights at their workplaces on when they leave that is a waste of resources. As a hausmeister of DHBW, Sagheer waits till all students and professors leave the university building, then goes and turns all the lights off.
The building consists of n floors with stairs at the left and the right sides. Each floor has m rooms on the same line with a corridor that connects the left and right stairs passing by all the rooms. In other words, the building can be represented as a rectangle with n rows and m + 2 columns, where the first and the last columns represent the stairs, and the m columns in the middle represent rooms.
Sagheer is standing at the ground floor at the left stairs. He wants to turn all the lights off in such a way that he will not go upstairs until all lights in the floor he is standing at are off. Of course, Sagheer must visit a room to turn the light there off. It takes one minute for Sagheer to go to the next floor using stairs or to move from the current room/stairs to a neighboring room/stairs on the same floor. It takes no time for him to switch the light off in the room he is currently standing in. Help Sagheer find the minimum total time to turn off all the lights.
Note that Sagheer does not have to go back to his starting position, and he does not have to visit rooms where the light is already switched off.
Input
The first line contains two integers n and m (1 ≤ n ≤ 15 and 1 ≤ m ≤ 100) — the number of floors and the number of rooms in each floor, respectively.
The next n lines contains the building description. Each line contains a binary string of length m + 2 representing a floor (the left stairs, then m rooms, then the right stairs) where 0 indicates that the light is off and 1 indicates that the light is on. The floors are listed from top to bottom, so that the last line represents the ground floor.
The first and last characters of each string represent the left and the right stairs, respectively, so they are always 0.
Output
Print a single integer — the minimum total time needed to turn off all the lights.
Examples
Input
2 2
0010
0100
Output
5
Input
3 4
001000
000010
000010
Output
12
Input
4 3
01110
01110
01110
01110
Output
18
Note
In the first example, Sagheer will go to room 1 in the ground floor, then he will go to room 2 in the second floor using the left or right stairs.
In the second example, he will go to the fourth room in the ground floor, use right stairs, go to the fourth room in the second floor, use right stairs again, then go to the second room in the last floor.
In the third example, he will walk through the whole corridor alternating between the left and right stairs at each floor. | instruction | 0 | 68,623 | 8 | 137,246 |
Tags: bitmasks, brute force, dp
Correct Solution:
```
def variant(cur):
global minv
if len(cur) < len(rooms):
variant(cur + [0])
variant(cur + [1])
else:
curpos = 0
time = 0
for i in range(len(rooms) - 1):
if curpos != cur[i]:
time += m + 1
curpos = cur[i]
else:
time += 2 * rooms[i][curpos]
if i != 0:
time += 1
time += rooms[-1][curpos] + 1
if len(rooms) == 1:
time -= 1
minv = min(minv, time)
n, m = map(int, input().split())
minv = 1000000000
rooms = []
stopdel = False
for i in range(n):
line = input()
a = 0
for j in range(m + 2):
if line[j] == '1':
a = m + 1 - j
break
b = 0
for j in range(m + 1, -1, -1):
if line[j] == '1':
b = j
break
if a != 0 or b != 0 or stopdel:
rooms.append((b, a))
stopdel = True
rooms = rooms[::-1]
if not rooms:
print('0')
else:
variant([])
print(minv)
``` | output | 1 | 68,623 | 8 | 137,247 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
Some people leave the lights at their workplaces on when they leave that is a waste of resources. As a hausmeister of DHBW, Sagheer waits till all students and professors leave the university building, then goes and turns all the lights off.
The building consists of n floors with stairs at the left and the right sides. Each floor has m rooms on the same line with a corridor that connects the left and right stairs passing by all the rooms. In other words, the building can be represented as a rectangle with n rows and m + 2 columns, where the first and the last columns represent the stairs, and the m columns in the middle represent rooms.
Sagheer is standing at the ground floor at the left stairs. He wants to turn all the lights off in such a way that he will not go upstairs until all lights in the floor he is standing at are off. Of course, Sagheer must visit a room to turn the light there off. It takes one minute for Sagheer to go to the next floor using stairs or to move from the current room/stairs to a neighboring room/stairs on the same floor. It takes no time for him to switch the light off in the room he is currently standing in. Help Sagheer find the minimum total time to turn off all the lights.
Note that Sagheer does not have to go back to his starting position, and he does not have to visit rooms where the light is already switched off.
Input
The first line contains two integers n and m (1 ≤ n ≤ 15 and 1 ≤ m ≤ 100) — the number of floors and the number of rooms in each floor, respectively.
The next n lines contains the building description. Each line contains a binary string of length m + 2 representing a floor (the left stairs, then m rooms, then the right stairs) where 0 indicates that the light is off and 1 indicates that the light is on. The floors are listed from top to bottom, so that the last line represents the ground floor.
The first and last characters of each string represent the left and the right stairs, respectively, so they are always 0.
Output
Print a single integer — the minimum total time needed to turn off all the lights.
Examples
Input
2 2
0010
0100
Output
5
Input
3 4
001000
000010
000010
Output
12
Input
4 3
01110
01110
01110
01110
Output
18
Note
In the first example, Sagheer will go to room 1 in the ground floor, then he will go to room 2 in the second floor using the left or right stairs.
In the second example, he will go to the fourth room in the ground floor, use right stairs, go to the fourth room in the second floor, use right stairs again, then go to the second room in the last floor.
In the third example, he will walk through the whole corridor alternating between the left and right stairs at each floor.
Submitted Solution:
```
n, m = map(int,input().split())
a=['']*n
for i in range(n):
a[n-i-1]=input()
res, ll, rr, k, l, r = 0, 0, 0, 0, 0, 0
for s in a:
i, l, r = 0, 0, 0
for z in s:
if z=='1':
if l == 0: l = m - i + 1
r = i
i+=1
if k==0:
p, q, rr = ll+2*r, ll + m + 1, m + 1
else:
p, q = min(ll + 2*r, rr + m+1), min(ll + m+1,rr + 2*l)
if l or r:
res=min(ll+r+k,rr+l+k)
k+=1
ll, rr = p, q
print(res)
# Made By Mostafa_Khaled
``` | instruction | 0 | 68,624 | 8 | 137,248 |
Yes | output | 1 | 68,624 | 8 | 137,249 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
Some people leave the lights at their workplaces on when they leave that is a waste of resources. As a hausmeister of DHBW, Sagheer waits till all students and professors leave the university building, then goes and turns all the lights off.
The building consists of n floors with stairs at the left and the right sides. Each floor has m rooms on the same line with a corridor that connects the left and right stairs passing by all the rooms. In other words, the building can be represented as a rectangle with n rows and m + 2 columns, where the first and the last columns represent the stairs, and the m columns in the middle represent rooms.
Sagheer is standing at the ground floor at the left stairs. He wants to turn all the lights off in such a way that he will not go upstairs until all lights in the floor he is standing at are off. Of course, Sagheer must visit a room to turn the light there off. It takes one minute for Sagheer to go to the next floor using stairs or to move from the current room/stairs to a neighboring room/stairs on the same floor. It takes no time for him to switch the light off in the room he is currently standing in. Help Sagheer find the minimum total time to turn off all the lights.
Note that Sagheer does not have to go back to his starting position, and he does not have to visit rooms where the light is already switched off.
Input
The first line contains two integers n and m (1 ≤ n ≤ 15 and 1 ≤ m ≤ 100) — the number of floors and the number of rooms in each floor, respectively.
The next n lines contains the building description. Each line contains a binary string of length m + 2 representing a floor (the left stairs, then m rooms, then the right stairs) where 0 indicates that the light is off and 1 indicates that the light is on. The floors are listed from top to bottom, so that the last line represents the ground floor.
The first and last characters of each string represent the left and the right stairs, respectively, so they are always 0.
Output
Print a single integer — the minimum total time needed to turn off all the lights.
Examples
Input
2 2
0010
0100
Output
5
Input
3 4
001000
000010
000010
Output
12
Input
4 3
01110
01110
01110
01110
Output
18
Note
In the first example, Sagheer will go to room 1 in the ground floor, then he will go to room 2 in the second floor using the left or right stairs.
In the second example, he will go to the fourth room in the ground floor, use right stairs, go to the fourth room in the second floor, use right stairs again, then go to the second room in the last floor.
In the third example, he will walk through the whole corridor alternating between the left and right stairs at each floor.
Submitted Solution:
```
for _ in range(1):
n,m=map(int,input().split())
arr=[]
for i in range(n):
st=input()
arr.append(st)
arr=arr[::-1]
dp=[[m+1,m+1] for i in range(n)]
for i in range(n):
last=0
for j in range(1,m+1):
if arr[i][j]=='1':
last=j
dp[i][0]=last
last=0
count=1
for j in range(m,0,-1):
if arr[i][j]=='1':
last=count
count+=1
dp[i][1]=last
dp_final=[[0,0] for i in range(n)]
dp_final[0][1]=m+1
mini=dp[0][0]
for i in range(1,n):
dp_final[i][0]=min(dp_final[i-1][0]+2*dp[i-1][0]+1,dp_final[i-1][1]+m+2)
dp_final[i][1]=min(dp_final[i-1][1]+2*dp[i-1][1]+1,dp_final[i-1][0]+m+2)
if arr[i].count('1')>0:
mini=min(dp_final[i][0]+dp[i][0],dp_final[i][1]+dp[i][1])
if mini==9999999999:
print(0)
else:
print(mini)
``` | instruction | 0 | 68,625 | 8 | 137,250 |
Yes | output | 1 | 68,625 | 8 | 137,251 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
Some people leave the lights at their workplaces on when they leave that is a waste of resources. As a hausmeister of DHBW, Sagheer waits till all students and professors leave the university building, then goes and turns all the lights off.
The building consists of n floors with stairs at the left and the right sides. Each floor has m rooms on the same line with a corridor that connects the left and right stairs passing by all the rooms. In other words, the building can be represented as a rectangle with n rows and m + 2 columns, where the first and the last columns represent the stairs, and the m columns in the middle represent rooms.
Sagheer is standing at the ground floor at the left stairs. He wants to turn all the lights off in such a way that he will not go upstairs until all lights in the floor he is standing at are off. Of course, Sagheer must visit a room to turn the light there off. It takes one minute for Sagheer to go to the next floor using stairs or to move from the current room/stairs to a neighboring room/stairs on the same floor. It takes no time for him to switch the light off in the room he is currently standing in. Help Sagheer find the minimum total time to turn off all the lights.
Note that Sagheer does not have to go back to his starting position, and he does not have to visit rooms where the light is already switched off.
Input
The first line contains two integers n and m (1 ≤ n ≤ 15 and 1 ≤ m ≤ 100) — the number of floors and the number of rooms in each floor, respectively.
The next n lines contains the building description. Each line contains a binary string of length m + 2 representing a floor (the left stairs, then m rooms, then the right stairs) where 0 indicates that the light is off and 1 indicates that the light is on. The floors are listed from top to bottom, so that the last line represents the ground floor.
The first and last characters of each string represent the left and the right stairs, respectively, so they are always 0.
Output
Print a single integer — the minimum total time needed to turn off all the lights.
Examples
Input
2 2
0010
0100
Output
5
Input
3 4
001000
000010
000010
Output
12
Input
4 3
01110
01110
01110
01110
Output
18
Note
In the first example, Sagheer will go to room 1 in the ground floor, then he will go to room 2 in the second floor using the left or right stairs.
In the second example, he will go to the fourth room in the ground floor, use right stairs, go to the fourth room in the second floor, use right stairs again, then go to the second room in the last floor.
In the third example, he will walk through the whole corridor alternating between the left and right stairs at each floor.
Submitted Solution:
```
n,m=list(map(int,input().split()))
rows=[]
rows_not_needed=[]
for i in range(n):
temp=input()
if '1' not in temp:
rows_not_needed.append(i)
continue
rows.append(temp)
n=n-len(rows_not_needed)
if n==0:
print(0)
exit()
dp=[[0 for _ in range(2)] for _ in range(n)]
l=[0 for _ in range(n)]
r=[0 for _ in range(n)]
for i in range(0,n):
for j in range(0,m+2):
if rows[i][j]=='1':
r[i]=j
for j in range(m+1,-1,-1):
if rows[i][j]=='1':
l[i]=j
dp[0][0]=r[0]
dp[0][1]=m+1-l[0]
for i in range(1,n):
dp[i][0]=min(r[i]+m+1-r[i]+1+dp[i-1][1],r[i]+r[i]+1+dp[i-1][0])
dp[i][1]=min(m+1-l[i]+l[i]+1+dp[i-1][0],m+1-l[i]+m+1-l[i]+1+dp[i-1][1])
# print(l)
# print(r)
# print(dp)
for i in range(0,len(rows_not_needed)):
if rows_not_needed[i] !=i:
dp[n - 1][0]+=1
print(dp[n-1][0])
``` | instruction | 0 | 68,626 | 8 | 137,252 |
Yes | output | 1 | 68,626 | 8 | 137,253 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
Some people leave the lights at their workplaces on when they leave that is a waste of resources. As a hausmeister of DHBW, Sagheer waits till all students and professors leave the university building, then goes and turns all the lights off.
The building consists of n floors with stairs at the left and the right sides. Each floor has m rooms on the same line with a corridor that connects the left and right stairs passing by all the rooms. In other words, the building can be represented as a rectangle with n rows and m + 2 columns, where the first and the last columns represent the stairs, and the m columns in the middle represent rooms.
Sagheer is standing at the ground floor at the left stairs. He wants to turn all the lights off in such a way that he will not go upstairs until all lights in the floor he is standing at are off. Of course, Sagheer must visit a room to turn the light there off. It takes one minute for Sagheer to go to the next floor using stairs or to move from the current room/stairs to a neighboring room/stairs on the same floor. It takes no time for him to switch the light off in the room he is currently standing in. Help Sagheer find the minimum total time to turn off all the lights.
Note that Sagheer does not have to go back to his starting position, and he does not have to visit rooms where the light is already switched off.
Input
The first line contains two integers n and m (1 ≤ n ≤ 15 and 1 ≤ m ≤ 100) — the number of floors and the number of rooms in each floor, respectively.
The next n lines contains the building description. Each line contains a binary string of length m + 2 representing a floor (the left stairs, then m rooms, then the right stairs) where 0 indicates that the light is off and 1 indicates that the light is on. The floors are listed from top to bottom, so that the last line represents the ground floor.
The first and last characters of each string represent the left and the right stairs, respectively, so they are always 0.
Output
Print a single integer — the minimum total time needed to turn off all the lights.
Examples
Input
2 2
0010
0100
Output
5
Input
3 4
001000
000010
000010
Output
12
Input
4 3
01110
01110
01110
01110
Output
18
Note
In the first example, Sagheer will go to room 1 in the ground floor, then he will go to room 2 in the second floor using the left or right stairs.
In the second example, he will go to the fourth room in the ground floor, use right stairs, go to the fourth room in the second floor, use right stairs again, then go to the second room in the last floor.
In the third example, he will walk through the whole corridor alternating between the left and right stairs at each floor.
Submitted Solution:
```
import collections
import functools
import math
import random
import sys
import bisect
def In():
return map(int, sys.stdin.readline().split())
input = sys.stdin.readline
def sagheer():
n, m = In()
floors = []
ones = 0
for _ in range(n):
s = input()
left, right = m + 1, 0
now = 0
for i in range(len(s) - 2, 0, -1):
if s[i] == '1':
left = i
if not right:
right = i
ones += 1
now += 1
if left == m + 1:
left = -1
if not right:
right = -1
floors.append([left, right, now])
floors.reverse()
todo = [('l', 0, 0, ones)]
ans = float('inf')
while todo:
p, c, f, lights = todo.pop()
if not lights:
ans = min(ans, c)
continue
if p == 'l':
pos = floors[f][1]
if pos == -1:
todo.append(('l', c + 1, f + 1, lights))
continue
c += pos
else:
pos = floors[f][0]
if pos == -1:
todo.append(('r', c + 1, f + 1, lights))
continue
c += m - pos + 1
lights -= floors[f][2]
if f == n - 1 or not lights:
ans = min(ans, c)
continue
f += 1
todo.append(('l', c + pos + 1, f, lights))
todo.append(('r', c + m - pos + 2, f, lights))
return ans
print(sagheer())
``` | instruction | 0 | 68,627 | 8 | 137,254 |
Yes | output | 1 | 68,627 | 8 | 137,255 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
Some people leave the lights at their workplaces on when they leave that is a waste of resources. As a hausmeister of DHBW, Sagheer waits till all students and professors leave the university building, then goes and turns all the lights off.
The building consists of n floors with stairs at the left and the right sides. Each floor has m rooms on the same line with a corridor that connects the left and right stairs passing by all the rooms. In other words, the building can be represented as a rectangle with n rows and m + 2 columns, where the first and the last columns represent the stairs, and the m columns in the middle represent rooms.
Sagheer is standing at the ground floor at the left stairs. He wants to turn all the lights off in such a way that he will not go upstairs until all lights in the floor he is standing at are off. Of course, Sagheer must visit a room to turn the light there off. It takes one minute for Sagheer to go to the next floor using stairs or to move from the current room/stairs to a neighboring room/stairs on the same floor. It takes no time for him to switch the light off in the room he is currently standing in. Help Sagheer find the minimum total time to turn off all the lights.
Note that Sagheer does not have to go back to his starting position, and he does not have to visit rooms where the light is already switched off.
Input
The first line contains two integers n and m (1 ≤ n ≤ 15 and 1 ≤ m ≤ 100) — the number of floors and the number of rooms in each floor, respectively.
The next n lines contains the building description. Each line contains a binary string of length m + 2 representing a floor (the left stairs, then m rooms, then the right stairs) where 0 indicates that the light is off and 1 indicates that the light is on. The floors are listed from top to bottom, so that the last line represents the ground floor.
The first and last characters of each string represent the left and the right stairs, respectively, so they are always 0.
Output
Print a single integer — the minimum total time needed to turn off all the lights.
Examples
Input
2 2
0010
0100
Output
5
Input
3 4
001000
000010
000010
Output
12
Input
4 3
01110
01110
01110
01110
Output
18
Note
In the first example, Sagheer will go to room 1 in the ground floor, then he will go to room 2 in the second floor using the left or right stairs.
In the second example, he will go to the fourth room in the ground floor, use right stairs, go to the fourth room in the second floor, use right stairs again, then go to the second room in the last floor.
In the third example, he will walk through the whole corridor alternating between the left and right stairs at each floor.
Submitted Solution:
```
# IAWT
def first_one(row):
for i in range(len(row)):
if row[i] == '1': return i
return len(row) - 1
def last_one(row):
for i in range(len(row)-1, -1, -1):
if row[i] == '1': return i
return 0
def left_score(i):
la = last_one(l[i])
s = la
right_pur = m+1 - la + 1 + scores[i-1][1]
left_pur = la + 1 + scores[i-1][0]
s += min(right_pur, left_pur)
return s
def right_score(i):
la = first_one(l[i])
s = m+1-la
right_pur = m+1 - la + 1 + scores[i-1][1]
left_pur = la + 1 + scores[i-1][0]
s += min(right_pur, left_pur)
return s
n, m = list(map(int, input().split()))
l = [input() for i in range(n)]
scores = [[last_one(l[0]), m+1 - first_one(l[0])]] # Scores[n] = [sl, sr].
for i in range(1, n-1):
scores.append([left_score(i), right_score(i)])
print(left_score(n-1))
``` | instruction | 0 | 68,628 | 8 | 137,256 |
No | output | 1 | 68,628 | 8 | 137,257 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
Some people leave the lights at their workplaces on when they leave that is a waste of resources. As a hausmeister of DHBW, Sagheer waits till all students and professors leave the university building, then goes and turns all the lights off.
The building consists of n floors with stairs at the left and the right sides. Each floor has m rooms on the same line with a corridor that connects the left and right stairs passing by all the rooms. In other words, the building can be represented as a rectangle with n rows and m + 2 columns, where the first and the last columns represent the stairs, and the m columns in the middle represent rooms.
Sagheer is standing at the ground floor at the left stairs. He wants to turn all the lights off in such a way that he will not go upstairs until all lights in the floor he is standing at are off. Of course, Sagheer must visit a room to turn the light there off. It takes one minute for Sagheer to go to the next floor using stairs or to move from the current room/stairs to a neighboring room/stairs on the same floor. It takes no time for him to switch the light off in the room he is currently standing in. Help Sagheer find the minimum total time to turn off all the lights.
Note that Sagheer does not have to go back to his starting position, and he does not have to visit rooms where the light is already switched off.
Input
The first line contains two integers n and m (1 ≤ n ≤ 15 and 1 ≤ m ≤ 100) — the number of floors and the number of rooms in each floor, respectively.
The next n lines contains the building description. Each line contains a binary string of length m + 2 representing a floor (the left stairs, then m rooms, then the right stairs) where 0 indicates that the light is off and 1 indicates that the light is on. The floors are listed from top to bottom, so that the last line represents the ground floor.
The first and last characters of each string represent the left and the right stairs, respectively, so they are always 0.
Output
Print a single integer — the minimum total time needed to turn off all the lights.
Examples
Input
2 2
0010
0100
Output
5
Input
3 4
001000
000010
000010
Output
12
Input
4 3
01110
01110
01110
01110
Output
18
Note
In the first example, Sagheer will go to room 1 in the ground floor, then he will go to room 2 in the second floor using the left or right stairs.
In the second example, he will go to the fourth room in the ground floor, use right stairs, go to the fourth room in the second floor, use right stairs again, then go to the second room in the last floor.
In the third example, he will walk through the whole corridor alternating between the left and right stairs at each floor.
Submitted Solution:
```
n,m = list(map(int,input().split()))
k = 0
ans = 0
a = []
for i in range(n):
a.append(input())
a.reverse()
a.append('0')
i = 0
while True:
if k==0:
x = a[i].rindex('1')
ans += x
else:
x = a[i].rindex('1')
ans += m+1-x
if '1' in a[i+1]:
i+=1
else:
break
if x>m+1-x:
k = 1
ans += m+2-x
else:
k = 0
ans += x+1
print(ans)
``` | instruction | 0 | 68,629 | 8 | 137,258 |
No | output | 1 | 68,629 | 8 | 137,259 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
Some people leave the lights at their workplaces on when they leave that is a waste of resources. As a hausmeister of DHBW, Sagheer waits till all students and professors leave the university building, then goes and turns all the lights off.
The building consists of n floors with stairs at the left and the right sides. Each floor has m rooms on the same line with a corridor that connects the left and right stairs passing by all the rooms. In other words, the building can be represented as a rectangle with n rows and m + 2 columns, where the first and the last columns represent the stairs, and the m columns in the middle represent rooms.
Sagheer is standing at the ground floor at the left stairs. He wants to turn all the lights off in such a way that he will not go upstairs until all lights in the floor he is standing at are off. Of course, Sagheer must visit a room to turn the light there off. It takes one minute for Sagheer to go to the next floor using stairs or to move from the current room/stairs to a neighboring room/stairs on the same floor. It takes no time for him to switch the light off in the room he is currently standing in. Help Sagheer find the minimum total time to turn off all the lights.
Note that Sagheer does not have to go back to his starting position, and he does not have to visit rooms where the light is already switched off.
Input
The first line contains two integers n and m (1 ≤ n ≤ 15 and 1 ≤ m ≤ 100) — the number of floors and the number of rooms in each floor, respectively.
The next n lines contains the building description. Each line contains a binary string of length m + 2 representing a floor (the left stairs, then m rooms, then the right stairs) where 0 indicates that the light is off and 1 indicates that the light is on. The floors are listed from top to bottom, so that the last line represents the ground floor.
The first and last characters of each string represent the left and the right stairs, respectively, so they are always 0.
Output
Print a single integer — the minimum total time needed to turn off all the lights.
Examples
Input
2 2
0010
0100
Output
5
Input
3 4
001000
000010
000010
Output
12
Input
4 3
01110
01110
01110
01110
Output
18
Note
In the first example, Sagheer will go to room 1 in the ground floor, then he will go to room 2 in the second floor using the left or right stairs.
In the second example, he will go to the fourth room in the ground floor, use right stairs, go to the fourth room in the second floor, use right stairs again, then go to the second room in the last floor.
In the third example, he will walk through the whole corridor alternating between the left and right stairs at each floor.
Submitted Solution:
```
def R():
return map(int, input().strip().split())
n, m = R()
graph = [list(input()) for i in range(n)]
graph = graph[::-1]
dp = []
cost = 0
# print(graph)
for i in range(1, n):
L = m+1; R = 0
for j in range(m+2):
# print(i, j)
if graph[i][j] == '1':
L = j
break
for j in range(m+1, -1, -1):
if graph[i][j] == '1':
R = j
break
dp.append([L, R])
while len(dp) and dp[-1][0] == m+1:
graph.pop()
dp.pop()
n -= 1
for i in range(m, -1, -1):
if graph[0][i] == '1':
cost = i
break
else:
for i in range(len(dp)):
if dp[i][0] == m+1:
cost += 1
else:
cost += dp[i][1]
pos = cost
for i in range(1, n):
# print(pos, 'pos', cost)
if dp[i-1][0] == m+1:
cost += 1
continue
if pos + dp[i-1][1]+1 < 2*(m+1)-pos-dp[i-1][0]+1:
cost += pos + dp[i-1][1]+1
pos = dp[i-1][1]
else:
cost += 2*(m+1)-pos-dp[i-1][0]+1
pos = dp[i-1][0]
# print(pos, 'posii', cost)
print(cost)
``` | instruction | 0 | 68,630 | 8 | 137,260 |
No | output | 1 | 68,630 | 8 | 137,261 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
Some people leave the lights at their workplaces on when they leave that is a waste of resources. As a hausmeister of DHBW, Sagheer waits till all students and professors leave the university building, then goes and turns all the lights off.
The building consists of n floors with stairs at the left and the right sides. Each floor has m rooms on the same line with a corridor that connects the left and right stairs passing by all the rooms. In other words, the building can be represented as a rectangle with n rows and m + 2 columns, where the first and the last columns represent the stairs, and the m columns in the middle represent rooms.
Sagheer is standing at the ground floor at the left stairs. He wants to turn all the lights off in such a way that he will not go upstairs until all lights in the floor he is standing at are off. Of course, Sagheer must visit a room to turn the light there off. It takes one minute for Sagheer to go to the next floor using stairs or to move from the current room/stairs to a neighboring room/stairs on the same floor. It takes no time for him to switch the light off in the room he is currently standing in. Help Sagheer find the minimum total time to turn off all the lights.
Note that Sagheer does not have to go back to his starting position, and he does not have to visit rooms where the light is already switched off.
Input
The first line contains two integers n and m (1 ≤ n ≤ 15 and 1 ≤ m ≤ 100) — the number of floors and the number of rooms in each floor, respectively.
The next n lines contains the building description. Each line contains a binary string of length m + 2 representing a floor (the left stairs, then m rooms, then the right stairs) where 0 indicates that the light is off and 1 indicates that the light is on. The floors are listed from top to bottom, so that the last line represents the ground floor.
The first and last characters of each string represent the left and the right stairs, respectively, so they are always 0.
Output
Print a single integer — the minimum total time needed to turn off all the lights.
Examples
Input
2 2
0010
0100
Output
5
Input
3 4
001000
000010
000010
Output
12
Input
4 3
01110
01110
01110
01110
Output
18
Note
In the first example, Sagheer will go to room 1 in the ground floor, then he will go to room 2 in the second floor using the left or right stairs.
In the second example, he will go to the fourth room in the ground floor, use right stairs, go to the fourth room in the second floor, use right stairs again, then go to the second room in the last floor.
In the third example, he will walk through the whole corridor alternating between the left and right stairs at each floor.
Submitted Solution:
```
floors,rooms=map(int,input().split())
lis=[]
for i in range(floors):
lis.append(input())
ans=[float('Inf')]
def backtrack(bitmask,lis,floor,answer,initialpos):
length2=len(lis)
if length2==0:
ans[0]=min(ans[0],answer)
return
if bitmask=="":
length=len(lis[-1])
for i in range(length):
if lis[-1][i]=='1':
answer=i
initialpos=i
if answer==0:
initialpos=0
if bitmask and bitmask[-1]=='0':
answer+=initialpos
length=len(lis[-1])
initialpos=0
for i in range(length):
if lis[-1][i]=='1':
initialpos=i
answer+=initialpos+1
if bitmask and bitmask[-1]=='1':
length=len(lis[-1])
answer+=(length-initialpos-1)
initialpos=0
for i in range(length):
if lis[-1][i]=='1':
initialpos=i
break
answer+=(length-initialpos)
backtrack(bitmask+'0',lis[:length2-1],floor+1,answer,initialpos)
backtrack(bitmask+'1',lis[:length2-1],floor+1,answer,initialpos)
backtrack("",lis,0,0,0)
print(ans[0])
``` | instruction | 0 | 68,631 | 8 | 137,262 |
No | output | 1 | 68,631 | 8 | 137,263 |
Provide a correct Python 3 solution for this coding contest problem.
In the Ancient Kingdom of Snuke, there was a pyramid to strengthen the authority of Takahashi, the president of AtCoder Inc.
The pyramid had center coordinates (C_X, C_Y) and height H. The altitude of coordinates (X, Y) is max(H - |X - C_X| - |Y - C_Y|, 0).
Aoki, an explorer, conducted a survey to identify the center coordinates and height of this pyramid. As a result, he obtained the following information:
* C_X, C_Y was integers between 0 and 100 (inclusive), and H was an integer not less than 1.
* Additionally, he obtained N pieces of information. The i-th of them is: "the altitude of point (x_i, y_i) is h_i."
This was enough to identify the center coordinates and the height of the pyramid. Find these values with the clues above.
Constraints
* N is an integer between 1 and 100 (inclusive).
* x_i and y_i are integers between 0 and 100 (inclusive).
* h_i is an integer between 0 and 10^9 (inclusive).
* The N coordinates (x_1, y_1), (x_2, y_2), (x_3, y_3), ..., (x_N, y_N) are all different.
* The center coordinates and the height of the pyramid can be uniquely identified.
Input
Input is given from Standard Input in the following format:
N
x_1 y_1 h_1
x_2 y_2 h_2
x_3 y_3 h_3
:
x_N y_N h_N
Output
Print values C_X, C_Y and H representing the center coordinates and the height of the pyramid in one line, with spaces in between.
Examples
Input
4
2 3 5
2 1 5
1 2 5
3 2 5
Output
2 2 6
Input
2
0 0 100
1 1 98
Output
0 0 100
Input
3
99 1 191
100 1 192
99 0 192
Output
100 0 193 | instruction | 0 | 68,749 | 8 | 137,498 |
"Correct Solution:
```
n=int(input())
xyh=[list(map(int,input().split())) for _ in range(n)]
for x,y,h in xyh:
if h>0:
sx=x
sy=y
sh=h
for i in range(101):
for j in range(101):
th=abs(i-sx)+abs(j-sy)+sh
for x,y,h in xyh:
if h!=max(th-abs(i-x)-abs(j-y),0):
break
else:
break
else:
continue
break
print(i,j,th)
``` | output | 1 | 68,749 | 8 | 137,499 |
Provide a correct Python 3 solution for this coding contest problem.
In the Ancient Kingdom of Snuke, there was a pyramid to strengthen the authority of Takahashi, the president of AtCoder Inc.
The pyramid had center coordinates (C_X, C_Y) and height H. The altitude of coordinates (X, Y) is max(H - |X - C_X| - |Y - C_Y|, 0).
Aoki, an explorer, conducted a survey to identify the center coordinates and height of this pyramid. As a result, he obtained the following information:
* C_X, C_Y was integers between 0 and 100 (inclusive), and H was an integer not less than 1.
* Additionally, he obtained N pieces of information. The i-th of them is: "the altitude of point (x_i, y_i) is h_i."
This was enough to identify the center coordinates and the height of the pyramid. Find these values with the clues above.
Constraints
* N is an integer between 1 and 100 (inclusive).
* x_i and y_i are integers between 0 and 100 (inclusive).
* h_i is an integer between 0 and 10^9 (inclusive).
* The N coordinates (x_1, y_1), (x_2, y_2), (x_3, y_3), ..., (x_N, y_N) are all different.
* The center coordinates and the height of the pyramid can be uniquely identified.
Input
Input is given from Standard Input in the following format:
N
x_1 y_1 h_1
x_2 y_2 h_2
x_3 y_3 h_3
:
x_N y_N h_N
Output
Print values C_X, C_Y and H representing the center coordinates and the height of the pyramid in one line, with spaces in between.
Examples
Input
4
2 3 5
2 1 5
1 2 5
3 2 5
Output
2 2 6
Input
2
0 0 100
1 1 98
Output
0 0 100
Input
3
99 1 191
100 1 192
99 0 192
Output
100 0 193 | instruction | 0 | 68,750 | 8 | 137,500 |
"Correct Solution:
```
N = int(input())
xyh = [list(map(int,input().split())) for i in range(N)]
for i in range(N):
if xyh[i][2] != 0:
xs, ys, hs = xyh[i]
for xt in range(101):
for yt in range(101):
ht = hs + abs(xt - xs) + abs(yt - ys)
if all([xyh[i][2] == max(0, ht - abs(xt-xyh[i][0]) - abs(yt-xyh[i][1])) for i in range(N)]):
xa, ya, ha = xt, yt, ht
print(xa,ya,ha)
``` | output | 1 | 68,750 | 8 | 137,501 |
Provide a correct Python 3 solution for this coding contest problem.
In the Ancient Kingdom of Snuke, there was a pyramid to strengthen the authority of Takahashi, the president of AtCoder Inc.
The pyramid had center coordinates (C_X, C_Y) and height H. The altitude of coordinates (X, Y) is max(H - |X - C_X| - |Y - C_Y|, 0).
Aoki, an explorer, conducted a survey to identify the center coordinates and height of this pyramid. As a result, he obtained the following information:
* C_X, C_Y was integers between 0 and 100 (inclusive), and H was an integer not less than 1.
* Additionally, he obtained N pieces of information. The i-th of them is: "the altitude of point (x_i, y_i) is h_i."
This was enough to identify the center coordinates and the height of the pyramid. Find these values with the clues above.
Constraints
* N is an integer between 1 and 100 (inclusive).
* x_i and y_i are integers between 0 and 100 (inclusive).
* h_i is an integer between 0 and 10^9 (inclusive).
* The N coordinates (x_1, y_1), (x_2, y_2), (x_3, y_3), ..., (x_N, y_N) are all different.
* The center coordinates and the height of the pyramid can be uniquely identified.
Input
Input is given from Standard Input in the following format:
N
x_1 y_1 h_1
x_2 y_2 h_2
x_3 y_3 h_3
:
x_N y_N h_N
Output
Print values C_X, C_Y and H representing the center coordinates and the height of the pyramid in one line, with spaces in between.
Examples
Input
4
2 3 5
2 1 5
1 2 5
3 2 5
Output
2 2 6
Input
2
0 0 100
1 1 98
Output
0 0 100
Input
3
99 1 191
100 1 192
99 0 192
Output
100 0 193 | instruction | 0 | 68,751 | 8 | 137,502 |
"Correct Solution:
```
n=int(input())
L=sorted([list(map(int,input().split())) for i in range(n)],key=lambda x:x[2])
for cx in range(101):
for cy in range(101):
H=L[-1][2]+abs(L[-1][0]-cx)+abs(L[-1][1]-cy)
if all([L[i][2]==max(H-abs(L[i][0]-cx)-abs(L[i][1]-cy),0) for i in range(n-1)]):
print(cx,cy,H)
``` | output | 1 | 68,751 | 8 | 137,503 |
Provide a correct Python 3 solution for this coding contest problem.
In the Ancient Kingdom of Snuke, there was a pyramid to strengthen the authority of Takahashi, the president of AtCoder Inc.
The pyramid had center coordinates (C_X, C_Y) and height H. The altitude of coordinates (X, Y) is max(H - |X - C_X| - |Y - C_Y|, 0).
Aoki, an explorer, conducted a survey to identify the center coordinates and height of this pyramid. As a result, he obtained the following information:
* C_X, C_Y was integers between 0 and 100 (inclusive), and H was an integer not less than 1.
* Additionally, he obtained N pieces of information. The i-th of them is: "the altitude of point (x_i, y_i) is h_i."
This was enough to identify the center coordinates and the height of the pyramid. Find these values with the clues above.
Constraints
* N is an integer between 1 and 100 (inclusive).
* x_i and y_i are integers between 0 and 100 (inclusive).
* h_i is an integer between 0 and 10^9 (inclusive).
* The N coordinates (x_1, y_1), (x_2, y_2), (x_3, y_3), ..., (x_N, y_N) are all different.
* The center coordinates and the height of the pyramid can be uniquely identified.
Input
Input is given from Standard Input in the following format:
N
x_1 y_1 h_1
x_2 y_2 h_2
x_3 y_3 h_3
:
x_N y_N h_N
Output
Print values C_X, C_Y and H representing the center coordinates and the height of the pyramid in one line, with spaces in between.
Examples
Input
4
2 3 5
2 1 5
1 2 5
3 2 5
Output
2 2 6
Input
2
0 0 100
1 1 98
Output
0 0 100
Input
3
99 1 191
100 1 192
99 0 192
Output
100 0 193 | instruction | 0 | 68,752 | 8 | 137,504 |
"Correct Solution:
```
n=int(input())
L=[list(map(int,input().split())) for i in range(n)]
LSort=sorted(L,key=lambda x:x[2])
x,y,h=LSort[-1]
for cx in range(0,101):
for cy in range(0,101):
H=h+abs(x-cx)+abs(y-cy)
if all([h==max(H-abs(x-cx)-abs(y-cy),0) for x,y,h in LSort]):
print(cx,cy,H)
exit()
``` | output | 1 | 68,752 | 8 | 137,505 |
Provide a correct Python 3 solution for this coding contest problem.
In the Ancient Kingdom of Snuke, there was a pyramid to strengthen the authority of Takahashi, the president of AtCoder Inc.
The pyramid had center coordinates (C_X, C_Y) and height H. The altitude of coordinates (X, Y) is max(H - |X - C_X| - |Y - C_Y|, 0).
Aoki, an explorer, conducted a survey to identify the center coordinates and height of this pyramid. As a result, he obtained the following information:
* C_X, C_Y was integers between 0 and 100 (inclusive), and H was an integer not less than 1.
* Additionally, he obtained N pieces of information. The i-th of them is: "the altitude of point (x_i, y_i) is h_i."
This was enough to identify the center coordinates and the height of the pyramid. Find these values with the clues above.
Constraints
* N is an integer between 1 and 100 (inclusive).
* x_i and y_i are integers between 0 and 100 (inclusive).
* h_i is an integer between 0 and 10^9 (inclusive).
* The N coordinates (x_1, y_1), (x_2, y_2), (x_3, y_3), ..., (x_N, y_N) are all different.
* The center coordinates and the height of the pyramid can be uniquely identified.
Input
Input is given from Standard Input in the following format:
N
x_1 y_1 h_1
x_2 y_2 h_2
x_3 y_3 h_3
:
x_N y_N h_N
Output
Print values C_X, C_Y and H representing the center coordinates and the height of the pyramid in one line, with spaces in between.
Examples
Input
4
2 3 5
2 1 5
1 2 5
3 2 5
Output
2 2 6
Input
2
0 0 100
1 1 98
Output
0 0 100
Input
3
99 1 191
100 1 192
99 0 192
Output
100 0 193 | instruction | 0 | 68,754 | 8 | 137,508 |
"Correct Solution:
```
N = int(input())
arr = [list(map(int, input().split())) for _ in range(N)]
arr.sort(key=lambda l:-l[2])
for cx in range(101):
for cy in range(101):
ch = None
for x, y, h in arr:
t = h + abs(cx-x) + abs(cy-y)
if h > 0:
if ch is not None and t != ch:
break
ch = t
else:
if t < ch:
break
else:
print(cx, cy, ch)
exit()
``` | output | 1 | 68,754 | 8 | 137,509 |
Provide a correct Python 3 solution for this coding contest problem.
In the Ancient Kingdom of Snuke, there was a pyramid to strengthen the authority of Takahashi, the president of AtCoder Inc.
The pyramid had center coordinates (C_X, C_Y) and height H. The altitude of coordinates (X, Y) is max(H - |X - C_X| - |Y - C_Y|, 0).
Aoki, an explorer, conducted a survey to identify the center coordinates and height of this pyramid. As a result, he obtained the following information:
* C_X, C_Y was integers between 0 and 100 (inclusive), and H was an integer not less than 1.
* Additionally, he obtained N pieces of information. The i-th of them is: "the altitude of point (x_i, y_i) is h_i."
This was enough to identify the center coordinates and the height of the pyramid. Find these values with the clues above.
Constraints
* N is an integer between 1 and 100 (inclusive).
* x_i and y_i are integers between 0 and 100 (inclusive).
* h_i is an integer between 0 and 10^9 (inclusive).
* The N coordinates (x_1, y_1), (x_2, y_2), (x_3, y_3), ..., (x_N, y_N) are all different.
* The center coordinates and the height of the pyramid can be uniquely identified.
Input
Input is given from Standard Input in the following format:
N
x_1 y_1 h_1
x_2 y_2 h_2
x_3 y_3 h_3
:
x_N y_N h_N
Output
Print values C_X, C_Y and H representing the center coordinates and the height of the pyramid in one line, with spaces in between.
Examples
Input
4
2 3 5
2 1 5
1 2 5
3 2 5
Output
2 2 6
Input
2
0 0 100
1 1 98
Output
0 0 100
Input
3
99 1 191
100 1 192
99 0 192
Output
100 0 193 | instruction | 0 | 68,755 | 8 | 137,510 |
"Correct Solution:
```
N = int(input())
List = [[int(i) for i in input().split()] for _ in range(N)]
for xt, yt, ht in List:
if ht > 0:
break
for px in range(0, 101):
for py in range(0, 101):
H = ht + abs(px - xt) + abs(py - yt)
if len(list(filter(lambda x: x[2] != max(H - abs(px - x[0]) - abs(py - x[1]), 0), List))) == 0:
print(px, py, H)
break
else:
continue
break
``` | output | 1 | 68,755 | 8 | 137,511 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
<image>
William owns a flat in central London. He decided to rent his flat out for the next n days to earn some money.
Since his flat is in the center of the city, he instantly got m offers in the form (l_i, r_i), which means that someone wants to book the flat from day l_i until day r_i inclusive. To avoid spending a lot of time figuring out whether it's profitable for him to accept an offer, William decided to develop an algorithm. The algorithm processes all offers as they arrive and will only accept offer i if the following two conditions are satisfied:
* r_i - l_i + 1 ≥ x.
* None of the days between l_i and r_i are occupied by a previously accepted offer
William isn't sure what value x should have and he asks you for help. For all x from 1 to n he wants you to calculate the total number of days for which the flat would be occupied if the corresponding value will be assigned to x.
Input
The first line contains two integers n and m (1 ≤ n ≤ 5 ⋅ 10^4, 1 ≤ m ≤ 10^5), which are the number of days and the number of offers, respectively.
Each of the next m lines contains two integers l_i and r_i (1 ≤ l_i ≤ r_i ≤ n), which describe the i-th renting offer. All offers are given in chronological order.
Output
Print n integers. The number in i-th line must be equal to the number of days the flat would be occupied if the algorithm will use the value of x equal to i.
Example
Input
6 5
2 3
3 5
1 1
1 5
1 6
Output
3
2
3
5
5
6
Note
The description of segments from the first sample test for each x:
* x = 1 — algorithm will approve offers: 1 (2..3), 3 (1..1). The total number of days for which William's flat will be rented out is 3
* x = 2 — algorithm will approve offers: 1 (2..3). The total number of days for which William's flat will be rented out is 2
* x = 3 — algorithm will approve offers: 2 (3..5). The total number of days for which William's flat will be rented out is 3
* x = 4 — algorithm will approve offers: 4 (1..5). The total number of days for which William's flat will be rented out is 5
* x = 5 — algorithm will approve offers: 4 (1..5). The total number of days for which William's flat will be rented out is 5
* x = 6 — algorithm will approve offers: 5 (1..6). The total number of days for which William's flat will be rented out is 6
Submitted Solution:
```
#from itertools import product
#from itertools import combinations
#from collections import Counter
from collections import defaultdict
#from collections import deque # deque([iterable[, maxlen]]) #appendleft popleft rotate
#from heapq import heapify, heappop, heappush # func(heapifiedlist, item)
# sadness lies below
#from bisect import bisect_left, bisect_right, insort # func(sortedlist, item)
#from sys import setrecursionlimit
from sys import stdin, stderr
input = stdin.readline
def dbp(*args, **kwargs): # calling with dbp(locals()) is perfectly cromulent
print(*args, file=stderr, **kwargs)
def get_int_list():
return [int(x) for x in input().strip().split()]
def do_thing():
n, m = get_int_list()
d = defaultdict(list)
maxd = -1
for i in range(m):
l, r = get_int_list()
d[r-l+1].append((l, r))
maxd = max(maxd, r+1)
for x in range(1, n+1):
days = [False] * maxd
for k in sorted(d.keys()):
if k < x:
continue
for offer in d[k]:
l, r = offer
if any((days[idx] for idx in range(l, r+1))):
continue
for idx in range(l, r+1):
days[idx] = True
print(days.count(True))
def multicase():
maxcc = int(input().strip())
for cc in range(maxcc):
print(do_thing())
if __name__ == "__main__":
#multicase()
do_thing()
``` | instruction | 0 | 69,187 | 8 | 138,374 |
No | output | 1 | 69,187 | 8 | 138,375 |
Provide tags and a correct Python 3 solution for this coding contest problem.
Fox Ciel has n boxes in her room. They have the same size and weight, but they might have different strength. The i-th box can hold at most xi boxes on its top (we'll call xi the strength of the box).
Since all the boxes have the same size, Ciel cannot put more than one box directly on the top of some box. For example, imagine Ciel has three boxes: the first has strength 2, the second has strength 1 and the third has strength 1. She cannot put the second and the third box simultaneously directly on the top of the first one. But she can put the second box directly on the top of the first one, and then the third box directly on the top of the second one. We will call such a construction of boxes a pile.
<image>
Fox Ciel wants to construct piles from all the boxes. Each pile will contain some boxes from top to bottom, and there cannot be more than xi boxes on the top of i-th box. What is the minimal number of piles she needs to construct?
Input
The first line contains an integer n (1 ≤ n ≤ 100). The next line contains n integers x1, x2, ..., xn (0 ≤ xi ≤ 100).
Output
Output a single integer — the minimal possible number of piles.
Examples
Input
3
0 0 10
Output
2
Input
5
0 1 2 3 4
Output
1
Input
4
0 0 0 0
Output
4
Input
9
0 1 0 2 0 1 1 2 10
Output
3
Note
In example 1, one optimal way is to build 2 piles: the first pile contains boxes 1 and 3 (from top to bottom), the second pile contains only box 2.
<image>
In example 2, we can build only 1 pile that contains boxes 1, 2, 3, 4, 5 (from top to bottom).
<image> | instruction | 0 | 69,297 | 8 | 138,594 |
Tags: greedy, sortings
Correct Solution:
```
from collections import Counter as cs
n=int(input())
ls=[int(a) for a in input().split()]
ls.sort()
ls1=dict(cs(ls))
ctr1,ctr2=1,0
for i in range(n):
if ls1[ls[i]]:
ls1[ls[i]]-=1
for j in range(i,n):
if i!=j and ls[j]>=ctr1 and ls1[ls[j]]:
ctr1+=1
ls1[ls[j]]-=1
ctr2+=1
ctr1=1
print(ctr2)
``` | output | 1 | 69,297 | 8 | 138,595 |
Provide tags and a correct Python 3 solution for this coding contest problem.
Fox Ciel has n boxes in her room. They have the same size and weight, but they might have different strength. The i-th box can hold at most xi boxes on its top (we'll call xi the strength of the box).
Since all the boxes have the same size, Ciel cannot put more than one box directly on the top of some box. For example, imagine Ciel has three boxes: the first has strength 2, the second has strength 1 and the third has strength 1. She cannot put the second and the third box simultaneously directly on the top of the first one. But she can put the second box directly on the top of the first one, and then the third box directly on the top of the second one. We will call such a construction of boxes a pile.
<image>
Fox Ciel wants to construct piles from all the boxes. Each pile will contain some boxes from top to bottom, and there cannot be more than xi boxes on the top of i-th box. What is the minimal number of piles she needs to construct?
Input
The first line contains an integer n (1 ≤ n ≤ 100). The next line contains n integers x1, x2, ..., xn (0 ≤ xi ≤ 100).
Output
Output a single integer — the minimal possible number of piles.
Examples
Input
3
0 0 10
Output
2
Input
5
0 1 2 3 4
Output
1
Input
4
0 0 0 0
Output
4
Input
9
0 1 0 2 0 1 1 2 10
Output
3
Note
In example 1, one optimal way is to build 2 piles: the first pile contains boxes 1 and 3 (from top to bottom), the second pile contains only box 2.
<image>
In example 2, we can build only 1 pile that contains boxes 1, 2, 3, 4, 5 (from top to bottom).
<image> | instruction | 0 | 69,298 | 8 | 138,596 |
Tags: greedy, sortings
Correct Solution:
```
n = int(input())
val = [[]]
for x in sorted(int(x) for x in input().split()):
for l in val:
if x >= len(l):
l.append(x)
break
if len(val[-1]) > 0:
val.append([])
print(len(val) - 1)
``` | output | 1 | 69,298 | 8 | 138,597 |
Provide tags and a correct Python 3 solution for this coding contest problem.
Fox Ciel has n boxes in her room. They have the same size and weight, but they might have different strength. The i-th box can hold at most xi boxes on its top (we'll call xi the strength of the box).
Since all the boxes have the same size, Ciel cannot put more than one box directly on the top of some box. For example, imagine Ciel has three boxes: the first has strength 2, the second has strength 1 and the third has strength 1. She cannot put the second and the third box simultaneously directly on the top of the first one. But she can put the second box directly on the top of the first one, and then the third box directly on the top of the second one. We will call such a construction of boxes a pile.
<image>
Fox Ciel wants to construct piles from all the boxes. Each pile will contain some boxes from top to bottom, and there cannot be more than xi boxes on the top of i-th box. What is the minimal number of piles she needs to construct?
Input
The first line contains an integer n (1 ≤ n ≤ 100). The next line contains n integers x1, x2, ..., xn (0 ≤ xi ≤ 100).
Output
Output a single integer — the minimal possible number of piles.
Examples
Input
3
0 0 10
Output
2
Input
5
0 1 2 3 4
Output
1
Input
4
0 0 0 0
Output
4
Input
9
0 1 0 2 0 1 1 2 10
Output
3
Note
In example 1, one optimal way is to build 2 piles: the first pile contains boxes 1 and 3 (from top to bottom), the second pile contains only box 2.
<image>
In example 2, we can build only 1 pile that contains boxes 1, 2, 3, 4, 5 (from top to bottom).
<image> | instruction | 0 | 69,299 | 8 | 138,598 |
Tags: greedy, sortings
Correct Solution:
```
from collections import Counter
def check(arr):
l=len(arr)
for i in range(len(arr)):
if l-i-1>arr[i]:
return False
return True
def boredom(arr):
arr=sorted(arr,reverse=True)
for ans in range(1,len(arr)+1):
d={}
ind=0
for i in arr:
d[ind]=d.get(ind,[])+[i]
ind+=1
ind%=ans
flag=False
for i in d.keys():
if check(d[i])==False:
flag=True
break
if flag==False:
return ans
a=input()
lst=list(map(int,input().strip().split()))
print(boredom(lst))
``` | output | 1 | 69,299 | 8 | 138,599 |
Provide tags and a correct Python 3 solution for this coding contest problem.
Fox Ciel has n boxes in her room. They have the same size and weight, but they might have different strength. The i-th box can hold at most xi boxes on its top (we'll call xi the strength of the box).
Since all the boxes have the same size, Ciel cannot put more than one box directly on the top of some box. For example, imagine Ciel has three boxes: the first has strength 2, the second has strength 1 and the third has strength 1. She cannot put the second and the third box simultaneously directly on the top of the first one. But she can put the second box directly on the top of the first one, and then the third box directly on the top of the second one. We will call such a construction of boxes a pile.
<image>
Fox Ciel wants to construct piles from all the boxes. Each pile will contain some boxes from top to bottom, and there cannot be more than xi boxes on the top of i-th box. What is the minimal number of piles she needs to construct?
Input
The first line contains an integer n (1 ≤ n ≤ 100). The next line contains n integers x1, x2, ..., xn (0 ≤ xi ≤ 100).
Output
Output a single integer — the minimal possible number of piles.
Examples
Input
3
0 0 10
Output
2
Input
5
0 1 2 3 4
Output
1
Input
4
0 0 0 0
Output
4
Input
9
0 1 0 2 0 1 1 2 10
Output
3
Note
In example 1, one optimal way is to build 2 piles: the first pile contains boxes 1 and 3 (from top to bottom), the second pile contains only box 2.
<image>
In example 2, we can build only 1 pile that contains boxes 1, 2, 3, 4, 5 (from top to bottom).
<image> | instruction | 0 | 69,300 | 8 | 138,600 |
Tags: greedy, sortings
Correct Solution:
```
n = int(input())
nums = sorted(list(map(int, input().split(' '))))
v = []
b = [0] * 105
cnt = 0
k = 0
while cnt < n:
k += 1
for i in range(n):
if nums[i] >= len(v) and b[i] == 0:
v.append(nums[i])
b[i] = 1
cnt += 1
v = []
print(k)
``` | output | 1 | 69,300 | 8 | 138,601 |
Provide tags and a correct Python 3 solution for this coding contest problem.
Fox Ciel has n boxes in her room. They have the same size and weight, but they might have different strength. The i-th box can hold at most xi boxes on its top (we'll call xi the strength of the box).
Since all the boxes have the same size, Ciel cannot put more than one box directly on the top of some box. For example, imagine Ciel has three boxes: the first has strength 2, the second has strength 1 and the third has strength 1. She cannot put the second and the third box simultaneously directly on the top of the first one. But she can put the second box directly on the top of the first one, and then the third box directly on the top of the second one. We will call such a construction of boxes a pile.
<image>
Fox Ciel wants to construct piles from all the boxes. Each pile will contain some boxes from top to bottom, and there cannot be more than xi boxes on the top of i-th box. What is the minimal number of piles she needs to construct?
Input
The first line contains an integer n (1 ≤ n ≤ 100). The next line contains n integers x1, x2, ..., xn (0 ≤ xi ≤ 100).
Output
Output a single integer — the minimal possible number of piles.
Examples
Input
3
0 0 10
Output
2
Input
5
0 1 2 3 4
Output
1
Input
4
0 0 0 0
Output
4
Input
9
0 1 0 2 0 1 1 2 10
Output
3
Note
In example 1, one optimal way is to build 2 piles: the first pile contains boxes 1 and 3 (from top to bottom), the second pile contains only box 2.
<image>
In example 2, we can build only 1 pile that contains boxes 1, 2, 3, 4, 5 (from top to bottom).
<image> | instruction | 0 | 69,301 | 8 | 138,602 |
Tags: greedy, sortings
Correct Solution:
```
n=int(input())
ar=list(map(int,input().strip().split(' ')))
ar.sort()
i=0
li=list()
cnt=[0]*(101)
for i in ar:
cnt[i]+=1
for i in range(101):
if cnt[i]==0:
continue
if len(li)==00:
x=(i+1)
li.extend([x]*(cnt[i]//x))
if cnt[i]%x!=0:
li.append(cnt[i]%x)
else:
z=len(li)
for j in range(z):
x=i-li[j]+1
if x<cnt[i]:
cnt[i]-=x
li[j]+=x
else:
li[j]+=cnt[i]
cnt[i]=0
break
if cnt[i]!=0:
d=cnt[i]
li.extend([(i+1)]*(d//(i+1)))
if d%(i+1)!=0:
li.append(d%(i+1))
print(len(li))
``` | output | 1 | 69,301 | 8 | 138,603 |
Provide tags and a correct Python 3 solution for this coding contest problem.
Fox Ciel has n boxes in her room. They have the same size and weight, but they might have different strength. The i-th box can hold at most xi boxes on its top (we'll call xi the strength of the box).
Since all the boxes have the same size, Ciel cannot put more than one box directly on the top of some box. For example, imagine Ciel has three boxes: the first has strength 2, the second has strength 1 and the third has strength 1. She cannot put the second and the third box simultaneously directly on the top of the first one. But she can put the second box directly on the top of the first one, and then the third box directly on the top of the second one. We will call such a construction of boxes a pile.
<image>
Fox Ciel wants to construct piles from all the boxes. Each pile will contain some boxes from top to bottom, and there cannot be more than xi boxes on the top of i-th box. What is the minimal number of piles she needs to construct?
Input
The first line contains an integer n (1 ≤ n ≤ 100). The next line contains n integers x1, x2, ..., xn (0 ≤ xi ≤ 100).
Output
Output a single integer — the minimal possible number of piles.
Examples
Input
3
0 0 10
Output
2
Input
5
0 1 2 3 4
Output
1
Input
4
0 0 0 0
Output
4
Input
9
0 1 0 2 0 1 1 2 10
Output
3
Note
In example 1, one optimal way is to build 2 piles: the first pile contains boxes 1 and 3 (from top to bottom), the second pile contains only box 2.
<image>
In example 2, we can build only 1 pile that contains boxes 1, 2, 3, 4, 5 (from top to bottom).
<image> | instruction | 0 | 69,302 | 8 | 138,604 |
Tags: greedy, sortings
Correct Solution:
```
n=int(input())
l=list(map(int,input().split()))
l.sort()
i=0
v=[0]*n
out=0
while i<n:
if v[i]==0:
c=0
j=i
while j<n:
if l[j]>=c and v[j]==0:
v[j]=1
c+=1
j+=1
out+=1
i+=1
print(out)
``` | output | 1 | 69,302 | 8 | 138,605 |
Provide tags and a correct Python 3 solution for this coding contest problem.
Fox Ciel has n boxes in her room. They have the same size and weight, but they might have different strength. The i-th box can hold at most xi boxes on its top (we'll call xi the strength of the box).
Since all the boxes have the same size, Ciel cannot put more than one box directly on the top of some box. For example, imagine Ciel has three boxes: the first has strength 2, the second has strength 1 and the third has strength 1. She cannot put the second and the third box simultaneously directly on the top of the first one. But she can put the second box directly on the top of the first one, and then the third box directly on the top of the second one. We will call such a construction of boxes a pile.
<image>
Fox Ciel wants to construct piles from all the boxes. Each pile will contain some boxes from top to bottom, and there cannot be more than xi boxes on the top of i-th box. What is the minimal number of piles she needs to construct?
Input
The first line contains an integer n (1 ≤ n ≤ 100). The next line contains n integers x1, x2, ..., xn (0 ≤ xi ≤ 100).
Output
Output a single integer — the minimal possible number of piles.
Examples
Input
3
0 0 10
Output
2
Input
5
0 1 2 3 4
Output
1
Input
4
0 0 0 0
Output
4
Input
9
0 1 0 2 0 1 1 2 10
Output
3
Note
In example 1, one optimal way is to build 2 piles: the first pile contains boxes 1 and 3 (from top to bottom), the second pile contains only box 2.
<image>
In example 2, we can build only 1 pile that contains boxes 1, 2, 3, 4, 5 (from top to bottom).
<image> | instruction | 0 | 69,303 | 8 | 138,606 |
Tags: greedy, sortings
Correct Solution:
```
n = int(input())
a = [int(x) for x in input().split()]
a.sort()
pile,tc=0,n
visited = [0]*n
while tc != 0:
tt=0
for i in range(0,n):
if a[i]>=tt and visited[i] != 1:
visited[i]=1
tt+=1
tc-=1
if(tt>0):
pile+=1
print(pile)
``` | output | 1 | 69,303 | 8 | 138,607 |
Provide tags and a correct Python 3 solution for this coding contest problem.
Fox Ciel has n boxes in her room. They have the same size and weight, but they might have different strength. The i-th box can hold at most xi boxes on its top (we'll call xi the strength of the box).
Since all the boxes have the same size, Ciel cannot put more than one box directly on the top of some box. For example, imagine Ciel has three boxes: the first has strength 2, the second has strength 1 and the third has strength 1. She cannot put the second and the third box simultaneously directly on the top of the first one. But she can put the second box directly on the top of the first one, and then the third box directly on the top of the second one. We will call such a construction of boxes a pile.
<image>
Fox Ciel wants to construct piles from all the boxes. Each pile will contain some boxes from top to bottom, and there cannot be more than xi boxes on the top of i-th box. What is the minimal number of piles she needs to construct?
Input
The first line contains an integer n (1 ≤ n ≤ 100). The next line contains n integers x1, x2, ..., xn (0 ≤ xi ≤ 100).
Output
Output a single integer — the minimal possible number of piles.
Examples
Input
3
0 0 10
Output
2
Input
5
0 1 2 3 4
Output
1
Input
4
0 0 0 0
Output
4
Input
9
0 1 0 2 0 1 1 2 10
Output
3
Note
In example 1, one optimal way is to build 2 piles: the first pile contains boxes 1 and 3 (from top to bottom), the second pile contains only box 2.
<image>
In example 2, we can build only 1 pile that contains boxes 1, 2, 3, 4, 5 (from top to bottom).
<image> | instruction | 0 | 69,304 | 8 | 138,608 |
Tags: greedy, sortings
Correct Solution:
```
# from itertools import combinations
# from bisect import bisect_left
from collections import Counter
I = lambda: list(map(int, input().split()))
n, a = I(), I()
a.sort()
h = [1]
for el in a[1:]:
mn = min(h)
if el >= mn:
h[h.index(mn)] += 1
else:
h.append(1)
print(len(h))
``` | output | 1 | 69,304 | 8 | 138,609 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
Fox Ciel has n boxes in her room. They have the same size and weight, but they might have different strength. The i-th box can hold at most xi boxes on its top (we'll call xi the strength of the box).
Since all the boxes have the same size, Ciel cannot put more than one box directly on the top of some box. For example, imagine Ciel has three boxes: the first has strength 2, the second has strength 1 and the third has strength 1. She cannot put the second and the third box simultaneously directly on the top of the first one. But she can put the second box directly on the top of the first one, and then the third box directly on the top of the second one. We will call such a construction of boxes a pile.
<image>
Fox Ciel wants to construct piles from all the boxes. Each pile will contain some boxes from top to bottom, and there cannot be more than xi boxes on the top of i-th box. What is the minimal number of piles she needs to construct?
Input
The first line contains an integer n (1 ≤ n ≤ 100). The next line contains n integers x1, x2, ..., xn (0 ≤ xi ≤ 100).
Output
Output a single integer — the minimal possible number of piles.
Examples
Input
3
0 0 10
Output
2
Input
5
0 1 2 3 4
Output
1
Input
4
0 0 0 0
Output
4
Input
9
0 1 0 2 0 1 1 2 10
Output
3
Note
In example 1, one optimal way is to build 2 piles: the first pile contains boxes 1 and 3 (from top to bottom), the second pile contains only box 2.
<image>
In example 2, we can build only 1 pile that contains boxes 1, 2, 3, 4, 5 (from top to bottom).
<image>
Submitted Solution:
```
n=int(input())
l=sorted(map(int,input().split()))
pile,box=0,n
visited=[0]*n
while box!=0:
t=0
for i in range(n):
if l[i]>=t and visited[i]==0:
visited[i]=1
t+=1
box-=1
if t>0:
pile+=1
print(pile)
``` | instruction | 0 | 69,305 | 8 | 138,610 |
Yes | output | 1 | 69,305 | 8 | 138,611 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
Fox Ciel has n boxes in her room. They have the same size and weight, but they might have different strength. The i-th box can hold at most xi boxes on its top (we'll call xi the strength of the box).
Since all the boxes have the same size, Ciel cannot put more than one box directly on the top of some box. For example, imagine Ciel has three boxes: the first has strength 2, the second has strength 1 and the third has strength 1. She cannot put the second and the third box simultaneously directly on the top of the first one. But she can put the second box directly on the top of the first one, and then the third box directly on the top of the second one. We will call such a construction of boxes a pile.
<image>
Fox Ciel wants to construct piles from all the boxes. Each pile will contain some boxes from top to bottom, and there cannot be more than xi boxes on the top of i-th box. What is the minimal number of piles she needs to construct?
Input
The first line contains an integer n (1 ≤ n ≤ 100). The next line contains n integers x1, x2, ..., xn (0 ≤ xi ≤ 100).
Output
Output a single integer — the minimal possible number of piles.
Examples
Input
3
0 0 10
Output
2
Input
5
0 1 2 3 4
Output
1
Input
4
0 0 0 0
Output
4
Input
9
0 1 0 2 0 1 1 2 10
Output
3
Note
In example 1, one optimal way is to build 2 piles: the first pile contains boxes 1 and 3 (from top to bottom), the second pile contains only box 2.
<image>
In example 2, we can build only 1 pile that contains boxes 1, 2, 3, 4, 5 (from top to bottom).
<image>
Submitted Solution:
```
import sys
import collections
case = int(sys.stdin.readline());
test = sys.stdin.readline().split(" ");
num = [int(x) for x in test]
stats = collections.defaultdict(int);
for i in num:
stats[i]+=1;
key = sorted(stats)
total = 0;
while sum(stats.values())>0:
stack = [];
for i in key:
if(stats[i]>0):
while(len(stack)<=i and stats[i]>0):
stack.append(i);
stats[i]-=1;
total+=1
print(total)
``` | instruction | 0 | 69,306 | 8 | 138,612 |
Yes | output | 1 | 69,306 | 8 | 138,613 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
Fox Ciel has n boxes in her room. They have the same size and weight, but they might have different strength. The i-th box can hold at most xi boxes on its top (we'll call xi the strength of the box).
Since all the boxes have the same size, Ciel cannot put more than one box directly on the top of some box. For example, imagine Ciel has three boxes: the first has strength 2, the second has strength 1 and the third has strength 1. She cannot put the second and the third box simultaneously directly on the top of the first one. But she can put the second box directly on the top of the first one, and then the third box directly on the top of the second one. We will call such a construction of boxes a pile.
<image>
Fox Ciel wants to construct piles from all the boxes. Each pile will contain some boxes from top to bottom, and there cannot be more than xi boxes on the top of i-th box. What is the minimal number of piles she needs to construct?
Input
The first line contains an integer n (1 ≤ n ≤ 100). The next line contains n integers x1, x2, ..., xn (0 ≤ xi ≤ 100).
Output
Output a single integer — the minimal possible number of piles.
Examples
Input
3
0 0 10
Output
2
Input
5
0 1 2 3 4
Output
1
Input
4
0 0 0 0
Output
4
Input
9
0 1 0 2 0 1 1 2 10
Output
3
Note
In example 1, one optimal way is to build 2 piles: the first pile contains boxes 1 and 3 (from top to bottom), the second pile contains only box 2.
<image>
In example 2, we can build only 1 pile that contains boxes 1, 2, 3, 4, 5 (from top to bottom).
<image>
Submitted Solution:
```
def fox(lst):
result = 1
for i in range(len(lst)):
if lst[i] < i // result:
result += 1
return result
n = int(input())
a = [int(j) for j in input().split()]
print(fox(sorted(a)))
``` | instruction | 0 | 69,307 | 8 | 138,614 |
Yes | output | 1 | 69,307 | 8 | 138,615 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
Fox Ciel has n boxes in her room. They have the same size and weight, but they might have different strength. The i-th box can hold at most xi boxes on its top (we'll call xi the strength of the box).
Since all the boxes have the same size, Ciel cannot put more than one box directly on the top of some box. For example, imagine Ciel has three boxes: the first has strength 2, the second has strength 1 and the third has strength 1. She cannot put the second and the third box simultaneously directly on the top of the first one. But she can put the second box directly on the top of the first one, and then the third box directly on the top of the second one. We will call such a construction of boxes a pile.
<image>
Fox Ciel wants to construct piles from all the boxes. Each pile will contain some boxes from top to bottom, and there cannot be more than xi boxes on the top of i-th box. What is the minimal number of piles she needs to construct?
Input
The first line contains an integer n (1 ≤ n ≤ 100). The next line contains n integers x1, x2, ..., xn (0 ≤ xi ≤ 100).
Output
Output a single integer — the minimal possible number of piles.
Examples
Input
3
0 0 10
Output
2
Input
5
0 1 2 3 4
Output
1
Input
4
0 0 0 0
Output
4
Input
9
0 1 0 2 0 1 1 2 10
Output
3
Note
In example 1, one optimal way is to build 2 piles: the first pile contains boxes 1 and 3 (from top to bottom), the second pile contains only box 2.
<image>
In example 2, we can build only 1 pile that contains boxes 1, 2, 3, 4, 5 (from top to bottom).
<image>
Submitted Solution:
```
n=int(input())
arr=list(map(int,input().split()))
arr.sort()
for k in range(1,n+1):
i=0
v=0
ok=True
while i<n:
for j in range(i,min(i+k,n)):
if arr[j]<v:
ok=False
break
i+=k
v+=1
if ok:
print(k)
exit()
``` | instruction | 0 | 69,308 | 8 | 138,616 |
Yes | output | 1 | 69,308 | 8 | 138,617 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
Fox Ciel has n boxes in her room. They have the same size and weight, but they might have different strength. The i-th box can hold at most xi boxes on its top (we'll call xi the strength of the box).
Since all the boxes have the same size, Ciel cannot put more than one box directly on the top of some box. For example, imagine Ciel has three boxes: the first has strength 2, the second has strength 1 and the third has strength 1. She cannot put the second and the third box simultaneously directly on the top of the first one. But she can put the second box directly on the top of the first one, and then the third box directly on the top of the second one. We will call such a construction of boxes a pile.
<image>
Fox Ciel wants to construct piles from all the boxes. Each pile will contain some boxes from top to bottom, and there cannot be more than xi boxes on the top of i-th box. What is the minimal number of piles she needs to construct?
Input
The first line contains an integer n (1 ≤ n ≤ 100). The next line contains n integers x1, x2, ..., xn (0 ≤ xi ≤ 100).
Output
Output a single integer — the minimal possible number of piles.
Examples
Input
3
0 0 10
Output
2
Input
5
0 1 2 3 4
Output
1
Input
4
0 0 0 0
Output
4
Input
9
0 1 0 2 0 1 1 2 10
Output
3
Note
In example 1, one optimal way is to build 2 piles: the first pile contains boxes 1 and 3 (from top to bottom), the second pile contains only box 2.
<image>
In example 2, we can build only 1 pile that contains boxes 1, 2, 3, 4, 5 (from top to bottom).
<image>
Submitted Solution:
```
import sys
import collections
case = int(sys.stdin.readline());
test = sys.stdin.readline().split(" ");
num = [int(x) for x in test]
stats = collections.defaultdict(int);
for i in num:
stats[i]+=1;
total = 0;
while sum(stats.values())>0:
for i in stats:
if(stats[i]!=0):
stats[i] -=1;
total+=1
print(total)
``` | instruction | 0 | 69,309 | 8 | 138,618 |
No | output | 1 | 69,309 | 8 | 138,619 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
Fox Ciel has n boxes in her room. They have the same size and weight, but they might have different strength. The i-th box can hold at most xi boxes on its top (we'll call xi the strength of the box).
Since all the boxes have the same size, Ciel cannot put more than one box directly on the top of some box. For example, imagine Ciel has three boxes: the first has strength 2, the second has strength 1 and the third has strength 1. She cannot put the second and the third box simultaneously directly on the top of the first one. But she can put the second box directly on the top of the first one, and then the third box directly on the top of the second one. We will call such a construction of boxes a pile.
<image>
Fox Ciel wants to construct piles from all the boxes. Each pile will contain some boxes from top to bottom, and there cannot be more than xi boxes on the top of i-th box. What is the minimal number of piles she needs to construct?
Input
The first line contains an integer n (1 ≤ n ≤ 100). The next line contains n integers x1, x2, ..., xn (0 ≤ xi ≤ 100).
Output
Output a single integer — the minimal possible number of piles.
Examples
Input
3
0 0 10
Output
2
Input
5
0 1 2 3 4
Output
1
Input
4
0 0 0 0
Output
4
Input
9
0 1 0 2 0 1 1 2 10
Output
3
Note
In example 1, one optimal way is to build 2 piles: the first pile contains boxes 1 and 3 (from top to bottom), the second pile contains only box 2.
<image>
In example 2, we can build only 1 pile that contains boxes 1, 2, 3, 4, 5 (from top to bottom).
<image>
Submitted Solution:
```
t = [0 for i in range(101)]
Mx = 0
n = int(input())
a = list(map(int , input().split()))
for i in range(n):
t[a[i]] += 1
Mx = max(Mx,t[a[i]])
print(Mx)
``` | instruction | 0 | 69,310 | 8 | 138,620 |
No | output | 1 | 69,310 | 8 | 138,621 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
Fox Ciel has n boxes in her room. They have the same size and weight, but they might have different strength. The i-th box can hold at most xi boxes on its top (we'll call xi the strength of the box).
Since all the boxes have the same size, Ciel cannot put more than one box directly on the top of some box. For example, imagine Ciel has three boxes: the first has strength 2, the second has strength 1 and the third has strength 1. She cannot put the second and the third box simultaneously directly on the top of the first one. But she can put the second box directly on the top of the first one, and then the third box directly on the top of the second one. We will call such a construction of boxes a pile.
<image>
Fox Ciel wants to construct piles from all the boxes. Each pile will contain some boxes from top to bottom, and there cannot be more than xi boxes on the top of i-th box. What is the minimal number of piles she needs to construct?
Input
The first line contains an integer n (1 ≤ n ≤ 100). The next line contains n integers x1, x2, ..., xn (0 ≤ xi ≤ 100).
Output
Output a single integer — the minimal possible number of piles.
Examples
Input
3
0 0 10
Output
2
Input
5
0 1 2 3 4
Output
1
Input
4
0 0 0 0
Output
4
Input
9
0 1 0 2 0 1 1 2 10
Output
3
Note
In example 1, one optimal way is to build 2 piles: the first pile contains boxes 1 and 3 (from top to bottom), the second pile contains only box 2.
<image>
In example 2, we can build only 1 pile that contains boxes 1, 2, 3, 4, 5 (from top to bottom).
<image>
Submitted Solution:
```
n=int(input())
a=map(int,input().split())
a=sorted(a,reverse=True)
u=[False for i in range(n)]
l=0
ml=0
ans=0
for i in range(n):
if not u[i]:
if l==ml:
ans+=1
ml=a[i]+1
l=1
else:
l+=1
u[i]=True
prev=a[i]
for j in range(i+1,n):
if l==ml:
break
if not u[j] and a[j]<prev:
ml=a[j]+1
l=1
prev=a[j]
u[j]=True
print(ans)
``` | instruction | 0 | 69,311 | 8 | 138,622 |
No | output | 1 | 69,311 | 8 | 138,623 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
Fox Ciel has n boxes in her room. They have the same size and weight, but they might have different strength. The i-th box can hold at most xi boxes on its top (we'll call xi the strength of the box).
Since all the boxes have the same size, Ciel cannot put more than one box directly on the top of some box. For example, imagine Ciel has three boxes: the first has strength 2, the second has strength 1 and the third has strength 1. She cannot put the second and the third box simultaneously directly on the top of the first one. But she can put the second box directly on the top of the first one, and then the third box directly on the top of the second one. We will call such a construction of boxes a pile.
<image>
Fox Ciel wants to construct piles from all the boxes. Each pile will contain some boxes from top to bottom, and there cannot be more than xi boxes on the top of i-th box. What is the minimal number of piles she needs to construct?
Input
The first line contains an integer n (1 ≤ n ≤ 100). The next line contains n integers x1, x2, ..., xn (0 ≤ xi ≤ 100).
Output
Output a single integer — the minimal possible number of piles.
Examples
Input
3
0 0 10
Output
2
Input
5
0 1 2 3 4
Output
1
Input
4
0 0 0 0
Output
4
Input
9
0 1 0 2 0 1 1 2 10
Output
3
Note
In example 1, one optimal way is to build 2 piles: the first pile contains boxes 1 and 3 (from top to bottom), the second pile contains only box 2.
<image>
In example 2, we can build only 1 pile that contains boxes 1, 2, 3, 4, 5 (from top to bottom).
<image>
Submitted Solution:
```
n = int(input())
arr = list(map(int, input().split()))
cnt = [0] * 101
for i in arr:
cnt[i] += 1
print(max(cnt))
``` | instruction | 0 | 69,312 | 8 | 138,624 |
No | output | 1 | 69,312 | 8 | 138,625 |
Provide tags and a correct Python 3 solution for this coding contest problem.
The capital of Berland has n multifloor buildings. The architect who built up the capital was very creative, so all the houses were built in one row.
Let's enumerate all the houses from left to right, starting with one. A house is considered to be luxurious if the number of floors in it is strictly greater than in all the houses with larger numbers. In other words, a house is luxurious if the number of floors in it is strictly greater than in all the houses, which are located to the right from it. In this task it is assumed that the heights of floors in the houses are the same.
The new architect is interested in n questions, i-th of them is about the following: "how many floors should be added to the i-th house to make it luxurious?" (for all i from 1 to n, inclusive). You need to help him cope with this task.
Note that all these questions are independent from each other — the answer to the question for house i does not affect other answers (i.e., the floors to the houses are not actually added).
Input
The first line of the input contains a single number n (1 ≤ n ≤ 105) — the number of houses in the capital of Berland.
The second line contains n space-separated positive integers hi (1 ≤ hi ≤ 109), where hi equals the number of floors in the i-th house.
Output
Print n integers a1, a2, ..., an, where number ai is the number of floors that need to be added to the house number i to make it luxurious. If the house is already luxurious and nothing needs to be added to it, then ai should be equal to zero.
All houses are numbered from left to right, starting from one.
Examples
Input
5
1 2 3 1 2
Output
3 2 0 2 0
Input
4
3 2 1 4
Output
2 3 4 0 | instruction | 0 | 69,403 | 8 | 138,806 |
Tags: implementation, math
Correct Solution:
```
n = int(input())
h = map(int, input().split()[::-1])
m_h = 0
res = []
for h in h:
if m_h < h:
res.append('0')
m_h = h
else:
res.append(str(m_h - h + 1))
print(" ".join(res[::-1]))
``` | output | 1 | 69,403 | 8 | 138,807 |
Provide tags and a correct Python 3 solution for this coding contest problem.
The capital of Berland has n multifloor buildings. The architect who built up the capital was very creative, so all the houses were built in one row.
Let's enumerate all the houses from left to right, starting with one. A house is considered to be luxurious if the number of floors in it is strictly greater than in all the houses with larger numbers. In other words, a house is luxurious if the number of floors in it is strictly greater than in all the houses, which are located to the right from it. In this task it is assumed that the heights of floors in the houses are the same.
The new architect is interested in n questions, i-th of them is about the following: "how many floors should be added to the i-th house to make it luxurious?" (for all i from 1 to n, inclusive). You need to help him cope with this task.
Note that all these questions are independent from each other — the answer to the question for house i does not affect other answers (i.e., the floors to the houses are not actually added).
Input
The first line of the input contains a single number n (1 ≤ n ≤ 105) — the number of houses in the capital of Berland.
The second line contains n space-separated positive integers hi (1 ≤ hi ≤ 109), where hi equals the number of floors in the i-th house.
Output
Print n integers a1, a2, ..., an, where number ai is the number of floors that need to be added to the house number i to make it luxurious. If the house is already luxurious and nothing needs to be added to it, then ai should be equal to zero.
All houses are numbered from left to right, starting from one.
Examples
Input
5
1 2 3 1 2
Output
3 2 0 2 0
Input
4
3 2 1 4
Output
2 3 4 0 | instruction | 0 | 69,404 | 8 | 138,808 |
Tags: implementation, math
Correct Solution:
```
import sys
try:
while True:
n = int(input())
val = list(map(int, input().split()))
maxval = 0
for i in range(n-1, -1, -1):
if maxval >= val[i]:
val[i] = maxval - val[i] + 1
else:
maxval = val[i]
val[i] = 0
print(*val)
except EOFError:
pass
``` | output | 1 | 69,404 | 8 | 138,809 |
Provide tags and a correct Python 3 solution for this coding contest problem.
The capital of Berland has n multifloor buildings. The architect who built up the capital was very creative, so all the houses were built in one row.
Let's enumerate all the houses from left to right, starting with one. A house is considered to be luxurious if the number of floors in it is strictly greater than in all the houses with larger numbers. In other words, a house is luxurious if the number of floors in it is strictly greater than in all the houses, which are located to the right from it. In this task it is assumed that the heights of floors in the houses are the same.
The new architect is interested in n questions, i-th of them is about the following: "how many floors should be added to the i-th house to make it luxurious?" (for all i from 1 to n, inclusive). You need to help him cope with this task.
Note that all these questions are independent from each other — the answer to the question for house i does not affect other answers (i.e., the floors to the houses are not actually added).
Input
The first line of the input contains a single number n (1 ≤ n ≤ 105) — the number of houses in the capital of Berland.
The second line contains n space-separated positive integers hi (1 ≤ hi ≤ 109), where hi equals the number of floors in the i-th house.
Output
Print n integers a1, a2, ..., an, where number ai is the number of floors that need to be added to the house number i to make it luxurious. If the house is already luxurious and nothing needs to be added to it, then ai should be equal to zero.
All houses are numbered from left to right, starting from one.
Examples
Input
5
1 2 3 1 2
Output
3 2 0 2 0
Input
4
3 2 1 4
Output
2 3 4 0 | instruction | 0 | 69,405 | 8 | 138,810 |
Tags: implementation, math
Correct Solution:
```
n = int(input())
ans = []
ma = 0
for h in list(reversed(list(map(int, input().split())))):
ans += [max(0, ma - h + 1)]
ma = max(ma, h)
print(' '.join(map(str, reversed(ans))))
``` | output | 1 | 69,405 | 8 | 138,811 |
Provide tags and a correct Python 3 solution for this coding contest problem.
The capital of Berland has n multifloor buildings. The architect who built up the capital was very creative, so all the houses were built in one row.
Let's enumerate all the houses from left to right, starting with one. A house is considered to be luxurious if the number of floors in it is strictly greater than in all the houses with larger numbers. In other words, a house is luxurious if the number of floors in it is strictly greater than in all the houses, which are located to the right from it. In this task it is assumed that the heights of floors in the houses are the same.
The new architect is interested in n questions, i-th of them is about the following: "how many floors should be added to the i-th house to make it luxurious?" (for all i from 1 to n, inclusive). You need to help him cope with this task.
Note that all these questions are independent from each other — the answer to the question for house i does not affect other answers (i.e., the floors to the houses are not actually added).
Input
The first line of the input contains a single number n (1 ≤ n ≤ 105) — the number of houses in the capital of Berland.
The second line contains n space-separated positive integers hi (1 ≤ hi ≤ 109), where hi equals the number of floors in the i-th house.
Output
Print n integers a1, a2, ..., an, where number ai is the number of floors that need to be added to the house number i to make it luxurious. If the house is already luxurious and nothing needs to be added to it, then ai should be equal to zero.
All houses are numbered from left to right, starting from one.
Examples
Input
5
1 2 3 1 2
Output
3 2 0 2 0
Input
4
3 2 1 4
Output
2 3 4 0 | instruction | 0 | 69,406 | 8 | 138,812 |
Tags: implementation, math
Correct Solution:
```
n = input()
buildings = list(map(int, input().split(' ')))
m = 0
result = []
for i in range(len(buildings) - 1, -1, -1):
b = buildings[i]
x = m - b
if x < 0:
result.append(0)
m = b
else:
result.append(x + 1)
print(' '.join(map(str, result[::-1])))
``` | output | 1 | 69,406 | 8 | 138,813 |
Provide tags and a correct Python 3 solution for this coding contest problem.
The capital of Berland has n multifloor buildings. The architect who built up the capital was very creative, so all the houses were built in one row.
Let's enumerate all the houses from left to right, starting with one. A house is considered to be luxurious if the number of floors in it is strictly greater than in all the houses with larger numbers. In other words, a house is luxurious if the number of floors in it is strictly greater than in all the houses, which are located to the right from it. In this task it is assumed that the heights of floors in the houses are the same.
The new architect is interested in n questions, i-th of them is about the following: "how many floors should be added to the i-th house to make it luxurious?" (for all i from 1 to n, inclusive). You need to help him cope with this task.
Note that all these questions are independent from each other — the answer to the question for house i does not affect other answers (i.e., the floors to the houses are not actually added).
Input
The first line of the input contains a single number n (1 ≤ n ≤ 105) — the number of houses in the capital of Berland.
The second line contains n space-separated positive integers hi (1 ≤ hi ≤ 109), where hi equals the number of floors in the i-th house.
Output
Print n integers a1, a2, ..., an, where number ai is the number of floors that need to be added to the house number i to make it luxurious. If the house is already luxurious and nothing needs to be added to it, then ai should be equal to zero.
All houses are numbered from left to right, starting from one.
Examples
Input
5
1 2 3 1 2
Output
3 2 0 2 0
Input
4
3 2 1 4
Output
2 3 4 0 | instruction | 0 | 69,407 | 8 | 138,814 |
Tags: implementation, math
Correct Solution:
```
n=int(input())
a=list(map(int,input().split()))
x=1
r=[]
for i in range(n-1,-1,-1):r+=[max(x-a[i],0)];x=max(x,a[i]+1)
print(' '.join(map(str,r[::-1])))
``` | output | 1 | 69,407 | 8 | 138,815 |
Provide tags and a correct Python 3 solution for this coding contest problem.
The capital of Berland has n multifloor buildings. The architect who built up the capital was very creative, so all the houses were built in one row.
Let's enumerate all the houses from left to right, starting with one. A house is considered to be luxurious if the number of floors in it is strictly greater than in all the houses with larger numbers. In other words, a house is luxurious if the number of floors in it is strictly greater than in all the houses, which are located to the right from it. In this task it is assumed that the heights of floors in the houses are the same.
The new architect is interested in n questions, i-th of them is about the following: "how many floors should be added to the i-th house to make it luxurious?" (for all i from 1 to n, inclusive). You need to help him cope with this task.
Note that all these questions are independent from each other — the answer to the question for house i does not affect other answers (i.e., the floors to the houses are not actually added).
Input
The first line of the input contains a single number n (1 ≤ n ≤ 105) — the number of houses in the capital of Berland.
The second line contains n space-separated positive integers hi (1 ≤ hi ≤ 109), where hi equals the number of floors in the i-th house.
Output
Print n integers a1, a2, ..., an, where number ai is the number of floors that need to be added to the house number i to make it luxurious. If the house is already luxurious and nothing needs to be added to it, then ai should be equal to zero.
All houses are numbered from left to right, starting from one.
Examples
Input
5
1 2 3 1 2
Output
3 2 0 2 0
Input
4
3 2 1 4
Output
2 3 4 0 | instruction | 0 | 69,408 | 8 | 138,816 |
Tags: implementation, math
Correct Solution:
```
n = int(input())
h = [int(i) for i in input().split()]
l = []
l_2 = []
for i in range(n):
l_2 += [0]
l_2[n-1] = h[n-1]
for i in range (n-2, 0, -1):
l_2[i] = max( l_2[i+1], h[i])
l_2 = l_2 + [0]
for i in range (n):
m = l_2[i+1]
g = max ( m - h[i] +1, 0)
l += [g]
for i in l:
print(i, end=' ')
``` | output | 1 | 69,408 | 8 | 138,817 |
Provide tags and a correct Python 3 solution for this coding contest problem.
The capital of Berland has n multifloor buildings. The architect who built up the capital was very creative, so all the houses were built in one row.
Let's enumerate all the houses from left to right, starting with one. A house is considered to be luxurious if the number of floors in it is strictly greater than in all the houses with larger numbers. In other words, a house is luxurious if the number of floors in it is strictly greater than in all the houses, which are located to the right from it. In this task it is assumed that the heights of floors in the houses are the same.
The new architect is interested in n questions, i-th of them is about the following: "how many floors should be added to the i-th house to make it luxurious?" (for all i from 1 to n, inclusive). You need to help him cope with this task.
Note that all these questions are independent from each other — the answer to the question for house i does not affect other answers (i.e., the floors to the houses are not actually added).
Input
The first line of the input contains a single number n (1 ≤ n ≤ 105) — the number of houses in the capital of Berland.
The second line contains n space-separated positive integers hi (1 ≤ hi ≤ 109), where hi equals the number of floors in the i-th house.
Output
Print n integers a1, a2, ..., an, where number ai is the number of floors that need to be added to the house number i to make it luxurious. If the house is already luxurious and nothing needs to be added to it, then ai should be equal to zero.
All houses are numbered from left to right, starting from one.
Examples
Input
5
1 2 3 1 2
Output
3 2 0 2 0
Input
4
3 2 1 4
Output
2 3 4 0 | instruction | 0 | 69,409 | 8 | 138,818 |
Tags: implementation, math
Correct Solution:
```
n = int(input())
a = list(map(int, input().split()))
_max = max(a)
b = [0] * n
b[n - 1] = 0
c = a[n - 1]
for i in range(n - 2, -1, -1):
if(a[i] > c):
b[i] = 0
c = a[i]
else:
c = max(c, a[i])
b[i] = c - a[i] + 1
for i in range(n):
print(b[i])
``` | output | 1 | 69,409 | 8 | 138,819 |
Provide tags and a correct Python 3 solution for this coding contest problem.
The capital of Berland has n multifloor buildings. The architect who built up the capital was very creative, so all the houses were built in one row.
Let's enumerate all the houses from left to right, starting with one. A house is considered to be luxurious if the number of floors in it is strictly greater than in all the houses with larger numbers. In other words, a house is luxurious if the number of floors in it is strictly greater than in all the houses, which are located to the right from it. In this task it is assumed that the heights of floors in the houses are the same.
The new architect is interested in n questions, i-th of them is about the following: "how many floors should be added to the i-th house to make it luxurious?" (for all i from 1 to n, inclusive). You need to help him cope with this task.
Note that all these questions are independent from each other — the answer to the question for house i does not affect other answers (i.e., the floors to the houses are not actually added).
Input
The first line of the input contains a single number n (1 ≤ n ≤ 105) — the number of houses in the capital of Berland.
The second line contains n space-separated positive integers hi (1 ≤ hi ≤ 109), where hi equals the number of floors in the i-th house.
Output
Print n integers a1, a2, ..., an, where number ai is the number of floors that need to be added to the house number i to make it luxurious. If the house is already luxurious and nothing needs to be added to it, then ai should be equal to zero.
All houses are numbered from left to right, starting from one.
Examples
Input
5
1 2 3 1 2
Output
3 2 0 2 0
Input
4
3 2 1 4
Output
2 3 4 0 | instruction | 0 | 69,410 | 8 | 138,820 |
Tags: implementation, math
Correct Solution:
```
n = int(input())
l = list(map(int , input().split()))
a = list(range(n+1)); y = 0
for i in range(n-1 , -1 , -1):
y = max(y , l[i])
a[i] = y
a[n] = 0
for i in range(n):
if (l[i] == a[i]) & (l[i] != a[i+1]):
print('0 ' , end = '')
else:
print(a[i]-l[i]+1 , end = '')
print(' ' , end = '')
``` | output | 1 | 69,410 | 8 | 138,821 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
The capital of Berland has n multifloor buildings. The architect who built up the capital was very creative, so all the houses were built in one row.
Let's enumerate all the houses from left to right, starting with one. A house is considered to be luxurious if the number of floors in it is strictly greater than in all the houses with larger numbers. In other words, a house is luxurious if the number of floors in it is strictly greater than in all the houses, which are located to the right from it. In this task it is assumed that the heights of floors in the houses are the same.
The new architect is interested in n questions, i-th of them is about the following: "how many floors should be added to the i-th house to make it luxurious?" (for all i from 1 to n, inclusive). You need to help him cope with this task.
Note that all these questions are independent from each other — the answer to the question for house i does not affect other answers (i.e., the floors to the houses are not actually added).
Input
The first line of the input contains a single number n (1 ≤ n ≤ 105) — the number of houses in the capital of Berland.
The second line contains n space-separated positive integers hi (1 ≤ hi ≤ 109), where hi equals the number of floors in the i-th house.
Output
Print n integers a1, a2, ..., an, where number ai is the number of floors that need to be added to the house number i to make it luxurious. If the house is already luxurious and nothing needs to be added to it, then ai should be equal to zero.
All houses are numbered from left to right, starting from one.
Examples
Input
5
1 2 3 1 2
Output
3 2 0 2 0
Input
4
3 2 1 4
Output
2 3 4 0
Submitted Solution:
```
n = int(input())
A = list(map(int, input().split()))
etaj = [0] * n
l = len(A)
ma = A[-1]
for i in range(-2, -l-1, -1):
if A[i] > ma:
ma = A[i]
etaj[i] = 0
"""
ma = A[i]
if A[i] <= A[i+1]:
etaj[i] = etaj[i+1] + A[i+1] - A[i]
elif (A[i] > A[i+1]) and (etaj[i+1] == 0):
etaj[i] = 0
elif (A[i] > A[i+1]) and (etaj[i+1] > 0):
etaj[i] = A[i+1] + etaj[i+1] - A[i]
"""
elif A[i] == ma:
etaj[i] = 1
else:
etaj[i] = ma - A[i] + 1
for elem in etaj: print(elem, end = ' ')
``` | instruction | 0 | 69,411 | 8 | 138,822 |
Yes | output | 1 | 69,411 | 8 | 138,823 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
The capital of Berland has n multifloor buildings. The architect who built up the capital was very creative, so all the houses were built in one row.
Let's enumerate all the houses from left to right, starting with one. A house is considered to be luxurious if the number of floors in it is strictly greater than in all the houses with larger numbers. In other words, a house is luxurious if the number of floors in it is strictly greater than in all the houses, which are located to the right from it. In this task it is assumed that the heights of floors in the houses are the same.
The new architect is interested in n questions, i-th of them is about the following: "how many floors should be added to the i-th house to make it luxurious?" (for all i from 1 to n, inclusive). You need to help him cope with this task.
Note that all these questions are independent from each other — the answer to the question for house i does not affect other answers (i.e., the floors to the houses are not actually added).
Input
The first line of the input contains a single number n (1 ≤ n ≤ 105) — the number of houses in the capital of Berland.
The second line contains n space-separated positive integers hi (1 ≤ hi ≤ 109), where hi equals the number of floors in the i-th house.
Output
Print n integers a1, a2, ..., an, where number ai is the number of floors that need to be added to the house number i to make it luxurious. If the house is already luxurious and nothing needs to be added to it, then ai should be equal to zero.
All houses are numbered from left to right, starting from one.
Examples
Input
5
1 2 3 1 2
Output
3 2 0 2 0
Input
4
3 2 1 4
Output
2 3 4 0
Submitted Solution:
```
n = int(input())
a = [int(x) for x in input().split()]
m = [0] * (n + 1)
m[n] = - 10 ** 9 - 7
for i in range(n-1,0,-1):
m[i] = max(m[i+1], a[i])
for i in range(n):
print(max(a[i], m[i+1] + 1) - a[i], end=' ')
``` | instruction | 0 | 69,412 | 8 | 138,824 |
Yes | output | 1 | 69,412 | 8 | 138,825 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
The capital of Berland has n multifloor buildings. The architect who built up the capital was very creative, so all the houses were built in one row.
Let's enumerate all the houses from left to right, starting with one. A house is considered to be luxurious if the number of floors in it is strictly greater than in all the houses with larger numbers. In other words, a house is luxurious if the number of floors in it is strictly greater than in all the houses, which are located to the right from it. In this task it is assumed that the heights of floors in the houses are the same.
The new architect is interested in n questions, i-th of them is about the following: "how many floors should be added to the i-th house to make it luxurious?" (for all i from 1 to n, inclusive). You need to help him cope with this task.
Note that all these questions are independent from each other — the answer to the question for house i does not affect other answers (i.e., the floors to the houses are not actually added).
Input
The first line of the input contains a single number n (1 ≤ n ≤ 105) — the number of houses in the capital of Berland.
The second line contains n space-separated positive integers hi (1 ≤ hi ≤ 109), where hi equals the number of floors in the i-th house.
Output
Print n integers a1, a2, ..., an, where number ai is the number of floors that need to be added to the house number i to make it luxurious. If the house is already luxurious and nothing needs to be added to it, then ai should be equal to zero.
All houses are numbered from left to right, starting from one.
Examples
Input
5
1 2 3 1 2
Output
3 2 0 2 0
Input
4
3 2 1 4
Output
2 3 4 0
Submitted Solution:
```
n = int(input())
hs = list(map(int, input().split()))
maxx = 0
ans = []
for h in reversed(hs):
if h > maxx:
ans.append(0)
else:
ans.append(maxx-h+1)
maxx = max(maxx, h)
print(' '.join(map(str, reversed(ans))))
``` | instruction | 0 | 69,413 | 8 | 138,826 |
Yes | output | 1 | 69,413 | 8 | 138,827 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
The capital of Berland has n multifloor buildings. The architect who built up the capital was very creative, so all the houses were built in one row.
Let's enumerate all the houses from left to right, starting with one. A house is considered to be luxurious if the number of floors in it is strictly greater than in all the houses with larger numbers. In other words, a house is luxurious if the number of floors in it is strictly greater than in all the houses, which are located to the right from it. In this task it is assumed that the heights of floors in the houses are the same.
The new architect is interested in n questions, i-th of them is about the following: "how many floors should be added to the i-th house to make it luxurious?" (for all i from 1 to n, inclusive). You need to help him cope with this task.
Note that all these questions are independent from each other — the answer to the question for house i does not affect other answers (i.e., the floors to the houses are not actually added).
Input
The first line of the input contains a single number n (1 ≤ n ≤ 105) — the number of houses in the capital of Berland.
The second line contains n space-separated positive integers hi (1 ≤ hi ≤ 109), where hi equals the number of floors in the i-th house.
Output
Print n integers a1, a2, ..., an, where number ai is the number of floors that need to be added to the house number i to make it luxurious. If the house is already luxurious and nothing needs to be added to it, then ai should be equal to zero.
All houses are numbered from left to right, starting from one.
Examples
Input
5
1 2 3 1 2
Output
3 2 0 2 0
Input
4
3 2 1 4
Output
2 3 4 0
Submitted Solution:
```
n=int(input())
arr=[int(x) for x in input().split()]
ans=[0 for i in range(n)]
maxi=arr[-1]
for i in range(n-2,-1,-1):
if arr[i]>maxi:
maxi=arr[i]
ans[i]=0
else:
ans[i]=maxi-arr[i]+1
for i in ans:
print(i,end=' ')
``` | instruction | 0 | 69,414 | 8 | 138,828 |
Yes | output | 1 | 69,414 | 8 | 138,829 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
The capital of Berland has n multifloor buildings. The architect who built up the capital was very creative, so all the houses were built in one row.
Let's enumerate all the houses from left to right, starting with one. A house is considered to be luxurious if the number of floors in it is strictly greater than in all the houses with larger numbers. In other words, a house is luxurious if the number of floors in it is strictly greater than in all the houses, which are located to the right from it. In this task it is assumed that the heights of floors in the houses are the same.
The new architect is interested in n questions, i-th of them is about the following: "how many floors should be added to the i-th house to make it luxurious?" (for all i from 1 to n, inclusive). You need to help him cope with this task.
Note that all these questions are independent from each other — the answer to the question for house i does not affect other answers (i.e., the floors to the houses are not actually added).
Input
The first line of the input contains a single number n (1 ≤ n ≤ 105) — the number of houses in the capital of Berland.
The second line contains n space-separated positive integers hi (1 ≤ hi ≤ 109), where hi equals the number of floors in the i-th house.
Output
Print n integers a1, a2, ..., an, where number ai is the number of floors that need to be added to the house number i to make it luxurious. If the house is already luxurious and nothing needs to be added to it, then ai should be equal to zero.
All houses are numbered from left to right, starting from one.
Examples
Input
5
1 2 3 1 2
Output
3 2 0 2 0
Input
4
3 2 1 4
Output
2 3 4 0
Submitted Solution:
```
n = int(input())
a = list(map(int, input().split()))
worst = 0
for i in reversed(range(n)):
b = a[i]
if a[i] <= worst:
a[i] = worst - a[i] + 1
if b > worst:
worst = b
print(' '.join(map(str, a)))
``` | instruction | 0 | 69,415 | 8 | 138,830 |
No | output | 1 | 69,415 | 8 | 138,831 |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.