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.
The weather is fine today and hence it's high time to climb the nearby pine and enjoy the landscape.
The pine's trunk includes several branches, located one above another and numbered from 2 to y. Some of them (more precise, from 2 to p) are occupied by tiny vile grasshoppers which you're at war with. These grasshoppers are known for their awesome jumping skills: the grasshopper at branch x can jump to branches <image>.
Keeping this in mind, you wisely decided to choose such a branch that none of the grasshoppers could interrupt you. At the same time you wanna settle as high as possible since the view from up there is simply breathtaking.
In other words, your goal is to find the highest branch that cannot be reached by any of the grasshoppers or report that it's impossible.
Input
The only line contains two integers p and y (2 ≤ p ≤ y ≤ 109).
Output
Output the number of the highest suitable branch. If there are none, print -1 instead.
Examples
Input
3 6
Output
5
Input
3 4
Output
-1
Note
In the first sample case grasshopper from branch 2 reaches branches 2, 4 and 6 while branch 3 is initially settled by another grasshopper. Therefore the answer is 5.
It immediately follows that there are no valid branches in second sample case. | instruction | 0 | 42,621 | 8 | 85,242 |
Tags: brute force, math, number theory
Correct Solution:
```
p = 0
y = 0
def prime_number(x):
if x <= 1:
return False
i = 2
while i * i <= x and i <= p:
if(x % i == 0):
return False
i += 1
return True
p, y = map(int,input().split())
flag = -1
num_list = []
for i in range(y,p,-1):
if(prime_number(i)):
print(i)
flag = 1
break
if flag != 1:
print("-1")
``` | output | 1 | 42,621 | 8 | 85,243 |
Provide tags and a correct Python 3 solution for this coding contest problem.
The weather is fine today and hence it's high time to climb the nearby pine and enjoy the landscape.
The pine's trunk includes several branches, located one above another and numbered from 2 to y. Some of them (more precise, from 2 to p) are occupied by tiny vile grasshoppers which you're at war with. These grasshoppers are known for their awesome jumping skills: the grasshopper at branch x can jump to branches <image>.
Keeping this in mind, you wisely decided to choose such a branch that none of the grasshoppers could interrupt you. At the same time you wanna settle as high as possible since the view from up there is simply breathtaking.
In other words, your goal is to find the highest branch that cannot be reached by any of the grasshoppers or report that it's impossible.
Input
The only line contains two integers p and y (2 ≤ p ≤ y ≤ 109).
Output
Output the number of the highest suitable branch. If there are none, print -1 instead.
Examples
Input
3 6
Output
5
Input
3 4
Output
-1
Note
In the first sample case grasshopper from branch 2 reaches branches 2, 4 and 6 while branch 3 is initially settled by another grasshopper. Therefore the answer is 5.
It immediately follows that there are no valid branches in second sample case. | instruction | 0 | 42,622 | 8 | 85,244 |
Tags: brute force, math, number theory
Correct Solution:
```
from math import sqrt, ceil
def isPrime(x):
if x < 2:
return False
if x < 4:
return True
if x % 2 == 0:
return False
for i in range(3, ceil(sqrt(x)) + 1, 2):
if x % i == 0:
return False
return True
def doesntDivide(x):
if p > sqrt(y):
return False
if x % 2 == 0:
return False
for i in range(3, p + 1, 2):
if x % i == 0:
return False
return True
p, y = map(int, input().split())
for i in range(y, max(p, y - 1000), -1):
if isPrime(i) or doesntDivide(i):
print(i)
break
else:
print(-1)
``` | output | 1 | 42,622 | 8 | 85,245 |
Provide a correct Python 3 solution for this coding contest problem.
C: Acrophobia
Yayoi Takasugi is a super-selling idol. There is one thing she is not good at. It's a high place ... She is extremely afraid of heights. This time, due to the producer's inadequacy, she decided to take on the following challenges on a variety show.
This location will be held in a room in a ninja mansion. The floor of this room is lined with square tiles, and some tiles have fallen out to form holes. If you fall through this hole, you will find yourself in a pond a few meters below. Yayoi's challenge is to start from the designated place in this room, collect all the scrolls placed in the room, and bring them to the goal point.
Yayoi can move in the room according to the following rules.
* When moving from one tile to the next, you can only move to the top, bottom, left, and right tiles.
* If it is not close to the hole, it will take 1 second to move to the next tile.
* If you get close to the hole, Yayoi will be scared and it will take time to move as shown in Fig. C-1. For example, it takes 3 seconds to move from [2] [2] to [1] [2] as shown by the arrow in the figure.
* If there are multiple holes nearby, you will be afraid of the nearest hole.
* The time it takes to take a scroll can be assumed to be 0.
<image>
---
Figure C-1: Travel time near the hole
Yayoi wants to finish this challenge as soon as possible. Your job is to help Yayoi write a program that asks for the shortest time to complete this challenge.
Input
The floor information of the ninja mansion is given.
First, W and H, which represent the size of the room, are entered on the first line, separated by spaces (2 <= W, H <= 100). A W character string is input to each of the following H lines. There are the following types of characters that represent floor information.
*'.': Walkable floor
* '#' : hole
*'S': Where Yayoi stands at the start
*'G': Yayoi's place to reach
*'M': Where the scroll is located
'S',' G'and'M' are walking floors. There is exactly one'S'and one'G'in the room, respectively. You may pass the goal without all the scrolls. There are a minimum of 1'M'and a maximum of 5'M'in the room.
Output
Collect all the scrolls and output the shortest time to reach the goal from the start on one line. You can always assume that the input data has such a route.
Output a line break at the end of the line.
Sample Input 1
3 4
S.M
...
...
M.G
Sample Output 1
9
Sample Input 2
4 4
S..M
....
... #
..G
Sample Output 2
18
Sample Input 3
11 7
M ......... M
...........
... #. S. # ...
...........
... #. G. # ...
...........
M ......... M
Sample Output 3
62
Example
Input
3 4
S.M
...
...
M.G
Output
9 | instruction | 0 | 42,854 | 8 | 85,708 |
"Correct Solution:
```
from itertools import permutations
from collections import deque
w, h = map(int, input().split())
mp = ["X" * (w + 4)] * 2 + ["XX" + input() + "XX" for _ in range(h)] + ["X" * (w + 4)] * 2
m_lst = []
holes = []
for y in range(2, h + 2):
for x in range(2, w + 2):
if mp[y][x] == "S":
sx, sy = x, y
if mp[y][x] == "G":
gx, gy = x, y
if mp[y][x] == "M":
m_lst.append((x, y))
if mp[y][x] == "#":
holes.append((x, y))
move_costs = [[1] * (w + 4) for _ in range(h + 4)]
for x, y in holes:
for ny in range(y - 2, y + 3):
for nx in range(x - 2, x + 3):
move_costs[ny][nx] = max(2, move_costs[ny][nx])
for ny in range(y - 1, y + 2):
for nx in range(x - 1, x + 2):
move_costs[ny][nx] = 3
def shortest(x1, y1):
INF = 10 ** 20
vec = ((1, 0), (0, -1), (-1, 0), (0, 1))
costs = [[INF] * (w + 4) for _ in range(h + 4)]
costs[y1][x1] = 0
que = deque()
que.append((0, x1, y1))
while que:
score, x, y = que.popleft()
new_score = score + move_costs[y][x]
for dx, dy in vec:
nx, ny = x + dx, y + dy
if mp[ny][nx] in {"S", "G", ".", "M"} and new_score < costs[ny][nx]:
costs[ny][nx] = new_score
que.append((new_score, nx, ny))
return costs
edges = []
for x, y in m_lst:
costs = shortest(x, y)
edge = []
for x2, y2 in m_lst:
edge.append(costs[y2][x2])
edge.append(costs[gy][gx])
edges.append(edge)
start_cost = shortest(sx, sy)
goal_cost = shortest(gx, gy)
ans = 10 ** 20
for t in permutations(range(len(edges)), len(edges)):
lst = list(t)
score = 0
for i in range(len(edges) - 1):
score += edges[lst[i]][lst[i + 1]]
xs, ys = m_lst[lst[0]]
xf, yf = m_lst[lst[-1]]
score += start_cost[ys][xs]
score += edges[lst[-1]][-1]
ans = min(ans, score)
print(ans)
``` | output | 1 | 42,854 | 8 | 85,709 |
Provide tags and a correct Python 3 solution for this coding contest problem.
And now the numerous qualifying tournaments for one of the most prestigious Russian contests Russian Codec Cup are over. All n participants who have made it to the finals found themselves in a huge m-floored 108-star hotel. Of course the first thought to come in a place like this is "How about checking out the elevator?".
The hotel's elevator moves between floors according to one never changing scheme. Initially (at the moment of time 0) the elevator is located on the 1-st floor, then it moves to the 2-nd floor, then — to the 3-rd floor and so on until it reaches the m-th floor. After that the elevator moves to floor m - 1, then to floor m - 2, and so on until it reaches the first floor. This process is repeated infinitely. We know that the elevator has infinite capacity; we also know that on every floor people get on the elevator immediately. Moving between the floors takes a unit of time.
For each of the n participant you are given si, which represents the floor where the i-th participant starts, fi, which represents the floor the i-th participant wants to reach, and ti, which represents the time when the i-th participant starts on the floor si.
For each participant print the minimum time of his/her arrival to the floor fi.
If the elevator stops on the floor si at the time ti, then the i-th participant can enter the elevator immediately. If the participant starts on the floor si and that's the floor he wanted to reach initially (si = fi), then the time of arrival to the floor fi for this participant is considered equal to ti.
Input
The first line contains two space-separated integers n and m (1 ≤ n ≤ 105, 2 ≤ m ≤ 108).
Next n lines contain information about the participants in the form of three space-separated integers si fi ti (1 ≤ si, fi ≤ m, 0 ≤ ti ≤ 108), described in the problem statement.
Output
Print n lines each containing one integer — the time of the arrival for each participant to the required floor.
Examples
Input
7 4
2 4 3
1 2 0
2 2 0
1 2 1
4 3 5
1 2 2
4 2 0
Output
9
1
0
7
10
7
5
Input
5 5
1 5 4
1 3 1
1 3 4
3 1 5
4 2 5
Output
12
10
10
8
7
Note
Let's consider the first sample. The first participant starts at floor s = 2 by the time equal to t = 3. To get to the floor f = 4, he has to wait until the time equals 7, that's the time when the elevator will go upwards for the second time. Then the first participant should get on the elevator and go two floors up. In this case the first participant gets to the floor f at time equal to 9. The second participant starts at the time t = 0 on the floor s = 1, enters the elevator immediately, and arrives to the floor f = 2. The third participant doesn't wait for the elevator, because he needs to arrive to the same floor where he starts. | instruction | 0 | 42,993 | 8 | 85,986 |
Tags: implementation, math
Correct Solution:
```
import sys
input = sys.stdin.readline
n,m = map(int, input().split())
for _ in range(n):
s,f,t = map(int, input().split())
floor = 1+(t%(2*m-2)) if t%(2*m-2)<m-1 else 2*m-1-t%(2*m-2)
up = t%(2*m-2)<m-1
if(floor==s):
time=0
elif(floor>s):
if(up):
time = (floor-s)+2*(m-floor)
up=False
else:
time = (floor-s)
else:
if(up):
time = (s-floor)
else:
time = (s-floor)+2*(floor-1)
up=True
if(s==f):
sys.stdout.write(str(t)+ '\n')
elif(s<f):
if(up):
sys.stdout.write(str(time+t+(f-s)) + '\n')
else:
sys.stdout.write(str(time+t+(f-s)+(2*s-2))+ '\n')
else:
if(up):
sys.stdout.write(str(time+t+(s-f)+(2*(m-s)))+ '\n')
else:
sys.stdout.write(str(time+t+(s-f))+ '\n')
``` | output | 1 | 42,993 | 8 | 85,987 |
Provide tags and a correct Python 3 solution for this coding contest problem.
And now the numerous qualifying tournaments for one of the most prestigious Russian contests Russian Codec Cup are over. All n participants who have made it to the finals found themselves in a huge m-floored 108-star hotel. Of course the first thought to come in a place like this is "How about checking out the elevator?".
The hotel's elevator moves between floors according to one never changing scheme. Initially (at the moment of time 0) the elevator is located on the 1-st floor, then it moves to the 2-nd floor, then — to the 3-rd floor and so on until it reaches the m-th floor. After that the elevator moves to floor m - 1, then to floor m - 2, and so on until it reaches the first floor. This process is repeated infinitely. We know that the elevator has infinite capacity; we also know that on every floor people get on the elevator immediately. Moving between the floors takes a unit of time.
For each of the n participant you are given si, which represents the floor where the i-th participant starts, fi, which represents the floor the i-th participant wants to reach, and ti, which represents the time when the i-th participant starts on the floor si.
For each participant print the minimum time of his/her arrival to the floor fi.
If the elevator stops on the floor si at the time ti, then the i-th participant can enter the elevator immediately. If the participant starts on the floor si and that's the floor he wanted to reach initially (si = fi), then the time of arrival to the floor fi for this participant is considered equal to ti.
Input
The first line contains two space-separated integers n and m (1 ≤ n ≤ 105, 2 ≤ m ≤ 108).
Next n lines contain information about the participants in the form of three space-separated integers si fi ti (1 ≤ si, fi ≤ m, 0 ≤ ti ≤ 108), described in the problem statement.
Output
Print n lines each containing one integer — the time of the arrival for each participant to the required floor.
Examples
Input
7 4
2 4 3
1 2 0
2 2 0
1 2 1
4 3 5
1 2 2
4 2 0
Output
9
1
0
7
10
7
5
Input
5 5
1 5 4
1 3 1
1 3 4
3 1 5
4 2 5
Output
12
10
10
8
7
Note
Let's consider the first sample. The first participant starts at floor s = 2 by the time equal to t = 3. To get to the floor f = 4, he has to wait until the time equals 7, that's the time when the elevator will go upwards for the second time. Then the first participant should get on the elevator and go two floors up. In this case the first participant gets to the floor f at time equal to 9. The second participant starts at the time t = 0 on the floor s = 1, enters the elevator immediately, and arrives to the floor f = 2. The third participant doesn't wait for the elevator, because he needs to arrive to the same floor where he starts. | instruction | 0 | 42,994 | 8 | 85,988 |
Tags: implementation, math
Correct Solution:
```
import sys
import math
ans = []
input = sys.stdin.readline
n, m = map(int, input().strip().split())
for _ in range(n):
start, end, t = map(int, input().strip().split())
start -= 1
end -= 1
if start == end:
ans.append(t)
continue
if start < end:
full = 2 * (m - 1)
ans.append(math.ceil((t - start) / full) * full + end)
continue
full = 2 * (m - 1)
ans.append(math.ceil((t - (full - start)) / full) * full + (full - end))
print('\n'.join(str(res) for res in ans))
``` | output | 1 | 42,994 | 8 | 85,989 |
Provide tags and a correct Python 3 solution for this coding contest problem.
And now the numerous qualifying tournaments for one of the most prestigious Russian contests Russian Codec Cup are over. All n participants who have made it to the finals found themselves in a huge m-floored 108-star hotel. Of course the first thought to come in a place like this is "How about checking out the elevator?".
The hotel's elevator moves between floors according to one never changing scheme. Initially (at the moment of time 0) the elevator is located on the 1-st floor, then it moves to the 2-nd floor, then — to the 3-rd floor and so on until it reaches the m-th floor. After that the elevator moves to floor m - 1, then to floor m - 2, and so on until it reaches the first floor. This process is repeated infinitely. We know that the elevator has infinite capacity; we also know that on every floor people get on the elevator immediately. Moving between the floors takes a unit of time.
For each of the n participant you are given si, which represents the floor where the i-th participant starts, fi, which represents the floor the i-th participant wants to reach, and ti, which represents the time when the i-th participant starts on the floor si.
For each participant print the minimum time of his/her arrival to the floor fi.
If the elevator stops on the floor si at the time ti, then the i-th participant can enter the elevator immediately. If the participant starts on the floor si and that's the floor he wanted to reach initially (si = fi), then the time of arrival to the floor fi for this participant is considered equal to ti.
Input
The first line contains two space-separated integers n and m (1 ≤ n ≤ 105, 2 ≤ m ≤ 108).
Next n lines contain information about the participants in the form of three space-separated integers si fi ti (1 ≤ si, fi ≤ m, 0 ≤ ti ≤ 108), described in the problem statement.
Output
Print n lines each containing one integer — the time of the arrival for each participant to the required floor.
Examples
Input
7 4
2 4 3
1 2 0
2 2 0
1 2 1
4 3 5
1 2 2
4 2 0
Output
9
1
0
7
10
7
5
Input
5 5
1 5 4
1 3 1
1 3 4
3 1 5
4 2 5
Output
12
10
10
8
7
Note
Let's consider the first sample. The first participant starts at floor s = 2 by the time equal to t = 3. To get to the floor f = 4, he has to wait until the time equals 7, that's the time when the elevator will go upwards for the second time. Then the first participant should get on the elevator and go two floors up. In this case the first participant gets to the floor f at time equal to 9. The second participant starts at the time t = 0 on the floor s = 1, enters the elevator immediately, and arrives to the floor f = 2. The third participant doesn't wait for the elevator, because he needs to arrive to the same floor where he starts. | instruction | 0 | 42,995 | 8 | 85,990 |
Tags: implementation, math
Correct Solution:
```
a,b=map(int,input().split())
ans=2*(b-1)
ok=[0]*a
for i in range(a):
x,y,z=map(int,input().split())
if x==y:ok[i]=(z)
elif x<y:
if z<x:ok[i]=y-1
else:ok[i]=ans*((z+ans-x)//ans)+y-1
else:
k=b-1
x=b+1-x
y=b+1-y
z-=k
if z < x:ok[i]=k+y - 1
else: ok[i]=k+ans * ((z + ans - x ) // ans) + y - 1
print(" ".join(map(str,ok)))
``` | output | 1 | 42,995 | 8 | 85,991 |
Provide tags and a correct Python 3 solution for this coding contest problem.
And now the numerous qualifying tournaments for one of the most prestigious Russian contests Russian Codec Cup are over. All n participants who have made it to the finals found themselves in a huge m-floored 108-star hotel. Of course the first thought to come in a place like this is "How about checking out the elevator?".
The hotel's elevator moves between floors according to one never changing scheme. Initially (at the moment of time 0) the elevator is located on the 1-st floor, then it moves to the 2-nd floor, then — to the 3-rd floor and so on until it reaches the m-th floor. After that the elevator moves to floor m - 1, then to floor m - 2, and so on until it reaches the first floor. This process is repeated infinitely. We know that the elevator has infinite capacity; we also know that on every floor people get on the elevator immediately. Moving between the floors takes a unit of time.
For each of the n participant you are given si, which represents the floor where the i-th participant starts, fi, which represents the floor the i-th participant wants to reach, and ti, which represents the time when the i-th participant starts on the floor si.
For each participant print the minimum time of his/her arrival to the floor fi.
If the elevator stops on the floor si at the time ti, then the i-th participant can enter the elevator immediately. If the participant starts on the floor si and that's the floor he wanted to reach initially (si = fi), then the time of arrival to the floor fi for this participant is considered equal to ti.
Input
The first line contains two space-separated integers n and m (1 ≤ n ≤ 105, 2 ≤ m ≤ 108).
Next n lines contain information about the participants in the form of three space-separated integers si fi ti (1 ≤ si, fi ≤ m, 0 ≤ ti ≤ 108), described in the problem statement.
Output
Print n lines each containing one integer — the time of the arrival for each participant to the required floor.
Examples
Input
7 4
2 4 3
1 2 0
2 2 0
1 2 1
4 3 5
1 2 2
4 2 0
Output
9
1
0
7
10
7
5
Input
5 5
1 5 4
1 3 1
1 3 4
3 1 5
4 2 5
Output
12
10
10
8
7
Note
Let's consider the first sample. The first participant starts at floor s = 2 by the time equal to t = 3. To get to the floor f = 4, he has to wait until the time equals 7, that's the time when the elevator will go upwards for the second time. Then the first participant should get on the elevator and go two floors up. In this case the first participant gets to the floor f at time equal to 9. The second participant starts at the time t = 0 on the floor s = 1, enters the elevator immediately, and arrives to the floor f = 2. The third participant doesn't wait for the elevator, because he needs to arrive to the same floor where he starts. | instruction | 0 | 42,996 | 8 | 85,992 |
Tags: implementation, math
Correct Solution:
```
n, m = map(int, input().split())
k = 2 * (m - 1)
for i in range(n):
s, f, t = map(int, input().split())
d = t % k
if s < f: print(k * (s <= d) + f - 1 + t - d)
elif f < s: print(k * (d + s > k + 1) + k + 1 - f + t - d)
else: print(t)
``` | output | 1 | 42,996 | 8 | 85,993 |
Provide tags and a correct Python 3 solution for this coding contest problem.
And now the numerous qualifying tournaments for one of the most prestigious Russian contests Russian Codec Cup are over. All n participants who have made it to the finals found themselves in a huge m-floored 108-star hotel. Of course the first thought to come in a place like this is "How about checking out the elevator?".
The hotel's elevator moves between floors according to one never changing scheme. Initially (at the moment of time 0) the elevator is located on the 1-st floor, then it moves to the 2-nd floor, then — to the 3-rd floor and so on until it reaches the m-th floor. After that the elevator moves to floor m - 1, then to floor m - 2, and so on until it reaches the first floor. This process is repeated infinitely. We know that the elevator has infinite capacity; we also know that on every floor people get on the elevator immediately. Moving between the floors takes a unit of time.
For each of the n participant you are given si, which represents the floor where the i-th participant starts, fi, which represents the floor the i-th participant wants to reach, and ti, which represents the time when the i-th participant starts on the floor si.
For each participant print the minimum time of his/her arrival to the floor fi.
If the elevator stops on the floor si at the time ti, then the i-th participant can enter the elevator immediately. If the participant starts on the floor si and that's the floor he wanted to reach initially (si = fi), then the time of arrival to the floor fi for this participant is considered equal to ti.
Input
The first line contains two space-separated integers n and m (1 ≤ n ≤ 105, 2 ≤ m ≤ 108).
Next n lines contain information about the participants in the form of three space-separated integers si fi ti (1 ≤ si, fi ≤ m, 0 ≤ ti ≤ 108), described in the problem statement.
Output
Print n lines each containing one integer — the time of the arrival for each participant to the required floor.
Examples
Input
7 4
2 4 3
1 2 0
2 2 0
1 2 1
4 3 5
1 2 2
4 2 0
Output
9
1
0
7
10
7
5
Input
5 5
1 5 4
1 3 1
1 3 4
3 1 5
4 2 5
Output
12
10
10
8
7
Note
Let's consider the first sample. The first participant starts at floor s = 2 by the time equal to t = 3. To get to the floor f = 4, he has to wait until the time equals 7, that's the time when the elevator will go upwards for the second time. Then the first participant should get on the elevator and go two floors up. In this case the first participant gets to the floor f at time equal to 9. The second participant starts at the time t = 0 on the floor s = 1, enters the elevator immediately, and arrives to the floor f = 2. The third participant doesn't wait for the elevator, because he needs to arrive to the same floor where he starts. | instruction | 0 | 42,997 | 8 | 85,994 |
Tags: implementation, math
Correct Solution:
```
from sys import stdin,stdout
a,b=map(int,stdin.readline().split())
ans=2*(b-1)
ok=[0]*a
for i in range(a):
x,y,z=map(int,stdin.readline().split())
if x==y:ok[i]=(z)
elif x<y:
if z<x:ok[i]=y-1
else:ok[i]=ans*((z+ans-x)//ans)+y-1
else:
k=b-1
x=b+1-x
y=b+1-y
z-=k
if z < x:ok[i]=k+y - 1
else: ok[i]=k+ans * ((z + ans - x ) // ans) + y - 1
stdout.write(" ".join(map(str,ok)))
``` | output | 1 | 42,997 | 8 | 85,995 |
Provide tags and a correct Python 3 solution for this coding contest problem.
And now the numerous qualifying tournaments for one of the most prestigious Russian contests Russian Codec Cup are over. All n participants who have made it to the finals found themselves in a huge m-floored 108-star hotel. Of course the first thought to come in a place like this is "How about checking out the elevator?".
The hotel's elevator moves between floors according to one never changing scheme. Initially (at the moment of time 0) the elevator is located on the 1-st floor, then it moves to the 2-nd floor, then — to the 3-rd floor and so on until it reaches the m-th floor. After that the elevator moves to floor m - 1, then to floor m - 2, and so on until it reaches the first floor. This process is repeated infinitely. We know that the elevator has infinite capacity; we also know that on every floor people get on the elevator immediately. Moving between the floors takes a unit of time.
For each of the n participant you are given si, which represents the floor where the i-th participant starts, fi, which represents the floor the i-th participant wants to reach, and ti, which represents the time when the i-th participant starts on the floor si.
For each participant print the minimum time of his/her arrival to the floor fi.
If the elevator stops on the floor si at the time ti, then the i-th participant can enter the elevator immediately. If the participant starts on the floor si and that's the floor he wanted to reach initially (si = fi), then the time of arrival to the floor fi for this participant is considered equal to ti.
Input
The first line contains two space-separated integers n and m (1 ≤ n ≤ 105, 2 ≤ m ≤ 108).
Next n lines contain information about the participants in the form of three space-separated integers si fi ti (1 ≤ si, fi ≤ m, 0 ≤ ti ≤ 108), described in the problem statement.
Output
Print n lines each containing one integer — the time of the arrival for each participant to the required floor.
Examples
Input
7 4
2 4 3
1 2 0
2 2 0
1 2 1
4 3 5
1 2 2
4 2 0
Output
9
1
0
7
10
7
5
Input
5 5
1 5 4
1 3 1
1 3 4
3 1 5
4 2 5
Output
12
10
10
8
7
Note
Let's consider the first sample. The first participant starts at floor s = 2 by the time equal to t = 3. To get to the floor f = 4, he has to wait until the time equals 7, that's the time when the elevator will go upwards for the second time. Then the first participant should get on the elevator and go two floors up. In this case the first participant gets to the floor f at time equal to 9. The second participant starts at the time t = 0 on the floor s = 1, enters the elevator immediately, and arrives to the floor f = 2. The third participant doesn't wait for the elevator, because he needs to arrive to the same floor where he starts. | instruction | 0 | 42,998 | 8 | 85,996 |
Tags: implementation, math
Correct Solution:
```
n, m = map(int, input().split())
k = 2 * (m - 1)
p = [0] * n
for i in range(n):
s, f, t = map(int, input().split())
d = t % k
if s < f: p[i] = (k if s <= d else 0) + f - 1 + t - d
elif f < s: p[i] = (k if d + s > k + 1 else 0) + k + 1 - f + t - d
else: p[i] = t
print('\n'.join(map(str, p)))
``` | output | 1 | 42,998 | 8 | 85,997 |
Provide tags and a correct Python 3 solution for this coding contest problem.
And now the numerous qualifying tournaments for one of the most prestigious Russian contests Russian Codec Cup are over. All n participants who have made it to the finals found themselves in a huge m-floored 108-star hotel. Of course the first thought to come in a place like this is "How about checking out the elevator?".
The hotel's elevator moves between floors according to one never changing scheme. Initially (at the moment of time 0) the elevator is located on the 1-st floor, then it moves to the 2-nd floor, then — to the 3-rd floor and so on until it reaches the m-th floor. After that the elevator moves to floor m - 1, then to floor m - 2, and so on until it reaches the first floor. This process is repeated infinitely. We know that the elevator has infinite capacity; we also know that on every floor people get on the elevator immediately. Moving between the floors takes a unit of time.
For each of the n participant you are given si, which represents the floor where the i-th participant starts, fi, which represents the floor the i-th participant wants to reach, and ti, which represents the time when the i-th participant starts on the floor si.
For each participant print the minimum time of his/her arrival to the floor fi.
If the elevator stops on the floor si at the time ti, then the i-th participant can enter the elevator immediately. If the participant starts on the floor si and that's the floor he wanted to reach initially (si = fi), then the time of arrival to the floor fi for this participant is considered equal to ti.
Input
The first line contains two space-separated integers n and m (1 ≤ n ≤ 105, 2 ≤ m ≤ 108).
Next n lines contain information about the participants in the form of three space-separated integers si fi ti (1 ≤ si, fi ≤ m, 0 ≤ ti ≤ 108), described in the problem statement.
Output
Print n lines each containing one integer — the time of the arrival for each participant to the required floor.
Examples
Input
7 4
2 4 3
1 2 0
2 2 0
1 2 1
4 3 5
1 2 2
4 2 0
Output
9
1
0
7
10
7
5
Input
5 5
1 5 4
1 3 1
1 3 4
3 1 5
4 2 5
Output
12
10
10
8
7
Note
Let's consider the first sample. The first participant starts at floor s = 2 by the time equal to t = 3. To get to the floor f = 4, he has to wait until the time equals 7, that's the time when the elevator will go upwards for the second time. Then the first participant should get on the elevator and go two floors up. In this case the first participant gets to the floor f at time equal to 9. The second participant starts at the time t = 0 on the floor s = 1, enters the elevator immediately, and arrives to the floor f = 2. The third participant doesn't wait for the elevator, because he needs to arrive to the same floor where he starts. | instruction | 0 | 42,999 | 8 | 85,998 |
Tags: implementation, math
Correct Solution:
```
n,m=map(int,input().split())
m-=1
a=[]
for i in range(n):
s,f,t=map(int,input().split())
s-=1
f-=1
if s==f:
a.append(t)
elif s<f:
c=s
while c<t:
c+=2*m
a.append(c+f-s)
else:
c=m*2-s
while c<t:
c+=2*m
a.append(c+s-f)
print('\n'.join(map(str, a)))
``` | output | 1 | 42,999 | 8 | 85,999 |
Provide tags and a correct Python 3 solution for this coding contest problem.
And now the numerous qualifying tournaments for one of the most prestigious Russian contests Russian Codec Cup are over. All n participants who have made it to the finals found themselves in a huge m-floored 108-star hotel. Of course the first thought to come in a place like this is "How about checking out the elevator?".
The hotel's elevator moves between floors according to one never changing scheme. Initially (at the moment of time 0) the elevator is located on the 1-st floor, then it moves to the 2-nd floor, then — to the 3-rd floor and so on until it reaches the m-th floor. After that the elevator moves to floor m - 1, then to floor m - 2, and so on until it reaches the first floor. This process is repeated infinitely. We know that the elevator has infinite capacity; we also know that on every floor people get on the elevator immediately. Moving between the floors takes a unit of time.
For each of the n participant you are given si, which represents the floor where the i-th participant starts, fi, which represents the floor the i-th participant wants to reach, and ti, which represents the time when the i-th participant starts on the floor si.
For each participant print the minimum time of his/her arrival to the floor fi.
If the elevator stops on the floor si at the time ti, then the i-th participant can enter the elevator immediately. If the participant starts on the floor si and that's the floor he wanted to reach initially (si = fi), then the time of arrival to the floor fi for this participant is considered equal to ti.
Input
The first line contains two space-separated integers n and m (1 ≤ n ≤ 105, 2 ≤ m ≤ 108).
Next n lines contain information about the participants in the form of three space-separated integers si fi ti (1 ≤ si, fi ≤ m, 0 ≤ ti ≤ 108), described in the problem statement.
Output
Print n lines each containing one integer — the time of the arrival for each participant to the required floor.
Examples
Input
7 4
2 4 3
1 2 0
2 2 0
1 2 1
4 3 5
1 2 2
4 2 0
Output
9
1
0
7
10
7
5
Input
5 5
1 5 4
1 3 1
1 3 4
3 1 5
4 2 5
Output
12
10
10
8
7
Note
Let's consider the first sample. The first participant starts at floor s = 2 by the time equal to t = 3. To get to the floor f = 4, he has to wait until the time equals 7, that's the time when the elevator will go upwards for the second time. Then the first participant should get on the elevator and go two floors up. In this case the first participant gets to the floor f at time equal to 9. The second participant starts at the time t = 0 on the floor s = 1, enters the elevator immediately, and arrives to the floor f = 2. The third participant doesn't wait for the elevator, because he needs to arrive to the same floor where he starts. | instruction | 0 | 43,000 | 8 | 86,000 |
Tags: implementation, math
Correct Solution:
```
n, m = map(int, input().split())
k = 2 * (m - 1)
ans = []
for _ in range(n):
s, f, t = map(int, input().split())
d = t % k
if s < f:
ad = (k if s <= d else 0) + f - 1 + t - d
elif f < s:
ad = (k if d + s > k + 1 else 0) + k + 1 - f + t - d
else:
ad = t
ans.append(ad)
print("\n".join(map(str, ans)))
``` | output | 1 | 43,000 | 8 | 86,001 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
And now the numerous qualifying tournaments for one of the most prestigious Russian contests Russian Codec Cup are over. All n participants who have made it to the finals found themselves in a huge m-floored 108-star hotel. Of course the first thought to come in a place like this is "How about checking out the elevator?".
The hotel's elevator moves between floors according to one never changing scheme. Initially (at the moment of time 0) the elevator is located on the 1-st floor, then it moves to the 2-nd floor, then — to the 3-rd floor and so on until it reaches the m-th floor. After that the elevator moves to floor m - 1, then to floor m - 2, and so on until it reaches the first floor. This process is repeated infinitely. We know that the elevator has infinite capacity; we also know that on every floor people get on the elevator immediately. Moving between the floors takes a unit of time.
For each of the n participant you are given si, which represents the floor where the i-th participant starts, fi, which represents the floor the i-th participant wants to reach, and ti, which represents the time when the i-th participant starts on the floor si.
For each participant print the minimum time of his/her arrival to the floor fi.
If the elevator stops on the floor si at the time ti, then the i-th participant can enter the elevator immediately. If the participant starts on the floor si and that's the floor he wanted to reach initially (si = fi), then the time of arrival to the floor fi for this participant is considered equal to ti.
Input
The first line contains two space-separated integers n and m (1 ≤ n ≤ 105, 2 ≤ m ≤ 108).
Next n lines contain information about the participants in the form of three space-separated integers si fi ti (1 ≤ si, fi ≤ m, 0 ≤ ti ≤ 108), described in the problem statement.
Output
Print n lines each containing one integer — the time of the arrival for each participant to the required floor.
Examples
Input
7 4
2 4 3
1 2 0
2 2 0
1 2 1
4 3 5
1 2 2
4 2 0
Output
9
1
0
7
10
7
5
Input
5 5
1 5 4
1 3 1
1 3 4
3 1 5
4 2 5
Output
12
10
10
8
7
Note
Let's consider the first sample. The first participant starts at floor s = 2 by the time equal to t = 3. To get to the floor f = 4, he has to wait until the time equals 7, that's the time when the elevator will go upwards for the second time. Then the first participant should get on the elevator and go two floors up. In this case the first participant gets to the floor f at time equal to 9. The second participant starts at the time t = 0 on the floor s = 1, enters the elevator immediately, and arrives to the floor f = 2. The third participant doesn't wait for the elevator, because he needs to arrive to the same floor where he starts.
Submitted Solution:
```
n=input()
n1=n.lower()
for i in n1:
if 'a'==i or 'e'==i or 'i'==i or 'o'==i or 'u'==i or 'y'==i:
i='.'
print(i,end='')
``` | instruction | 0 | 43,001 | 8 | 86,002 |
No | output | 1 | 43,001 | 8 | 86,003 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
And now the numerous qualifying tournaments for one of the most prestigious Russian contests Russian Codec Cup are over. All n participants who have made it to the finals found themselves in a huge m-floored 108-star hotel. Of course the first thought to come in a place like this is "How about checking out the elevator?".
The hotel's elevator moves between floors according to one never changing scheme. Initially (at the moment of time 0) the elevator is located on the 1-st floor, then it moves to the 2-nd floor, then — to the 3-rd floor and so on until it reaches the m-th floor. After that the elevator moves to floor m - 1, then to floor m - 2, and so on until it reaches the first floor. This process is repeated infinitely. We know that the elevator has infinite capacity; we also know that on every floor people get on the elevator immediately. Moving between the floors takes a unit of time.
For each of the n participant you are given si, which represents the floor where the i-th participant starts, fi, which represents the floor the i-th participant wants to reach, and ti, which represents the time when the i-th participant starts on the floor si.
For each participant print the minimum time of his/her arrival to the floor fi.
If the elevator stops on the floor si at the time ti, then the i-th participant can enter the elevator immediately. If the participant starts on the floor si and that's the floor he wanted to reach initially (si = fi), then the time of arrival to the floor fi for this participant is considered equal to ti.
Input
The first line contains two space-separated integers n and m (1 ≤ n ≤ 105, 2 ≤ m ≤ 108).
Next n lines contain information about the participants in the form of three space-separated integers si fi ti (1 ≤ si, fi ≤ m, 0 ≤ ti ≤ 108), described in the problem statement.
Output
Print n lines each containing one integer — the time of the arrival for each participant to the required floor.
Examples
Input
7 4
2 4 3
1 2 0
2 2 0
1 2 1
4 3 5
1 2 2
4 2 0
Output
9
1
0
7
10
7
5
Input
5 5
1 5 4
1 3 1
1 3 4
3 1 5
4 2 5
Output
12
10
10
8
7
Note
Let's consider the first sample. The first participant starts at floor s = 2 by the time equal to t = 3. To get to the floor f = 4, he has to wait until the time equals 7, that's the time when the elevator will go upwards for the second time. Then the first participant should get on the elevator and go two floors up. In this case the first participant gets to the floor f at time equal to 9. The second participant starts at the time t = 0 on the floor s = 1, enters the elevator immediately, and arrives to the floor f = 2. The third participant doesn't wait for the elevator, because he needs to arrive to the same floor where he starts.
Submitted Solution:
```
n, m = map(int, input().split())
for _ in range(n):
s, f, t = map(int, input().split())
result = t
t_cut = t % (2 * (m - 1))
if s == f:
result = t
elif t_cut >= (m - 1):
if 2 * (m - 1) - t_cut < (s - 1):
result += 2 * (m - 1) - ((s - 1) - (2 * (m - 1) - t_cut))
else:
result += (2 * (m - 1) - t_cut) - (s - 1)
if s < f:
result += (s - 1) + (f - 1)
else:
result += s - f
else:
if t_cut > (s - 1):
result += 2 * (m - 1) - t_cut - (s - 1)
else:
result += (s - 1) - t_cut
if s < f:
result += f - s
else:
result += 2 * (m - 1) - (s - 1) - (f - 1)
print(result)
``` | instruction | 0 | 43,002 | 8 | 86,004 |
No | output | 1 | 43,002 | 8 | 86,005 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
And now the numerous qualifying tournaments for one of the most prestigious Russian contests Russian Codec Cup are over. All n participants who have made it to the finals found themselves in a huge m-floored 108-star hotel. Of course the first thought to come in a place like this is "How about checking out the elevator?".
The hotel's elevator moves between floors according to one never changing scheme. Initially (at the moment of time 0) the elevator is located on the 1-st floor, then it moves to the 2-nd floor, then — to the 3-rd floor and so on until it reaches the m-th floor. After that the elevator moves to floor m - 1, then to floor m - 2, and so on until it reaches the first floor. This process is repeated infinitely. We know that the elevator has infinite capacity; we also know that on every floor people get on the elevator immediately. Moving between the floors takes a unit of time.
For each of the n participant you are given si, which represents the floor where the i-th participant starts, fi, which represents the floor the i-th participant wants to reach, and ti, which represents the time when the i-th participant starts on the floor si.
For each participant print the minimum time of his/her arrival to the floor fi.
If the elevator stops on the floor si at the time ti, then the i-th participant can enter the elevator immediately. If the participant starts on the floor si and that's the floor he wanted to reach initially (si = fi), then the time of arrival to the floor fi for this participant is considered equal to ti.
Input
The first line contains two space-separated integers n and m (1 ≤ n ≤ 105, 2 ≤ m ≤ 108).
Next n lines contain information about the participants in the form of three space-separated integers si fi ti (1 ≤ si, fi ≤ m, 0 ≤ ti ≤ 108), described in the problem statement.
Output
Print n lines each containing one integer — the time of the arrival for each participant to the required floor.
Examples
Input
7 4
2 4 3
1 2 0
2 2 0
1 2 1
4 3 5
1 2 2
4 2 0
Output
9
1
0
7
10
7
5
Input
5 5
1 5 4
1 3 1
1 3 4
3 1 5
4 2 5
Output
12
10
10
8
7
Note
Let's consider the first sample. The first participant starts at floor s = 2 by the time equal to t = 3. To get to the floor f = 4, he has to wait until the time equals 7, that's the time when the elevator will go upwards for the second time. Then the first participant should get on the elevator and go two floors up. In this case the first participant gets to the floor f at time equal to 9. The second participant starts at the time t = 0 on the floor s = 1, enters the elevator immediately, and arrives to the floor f = 2. The third participant doesn't wait for the elevator, because he needs to arrive to the same floor where he starts.
Submitted Solution:
```
n, m = map(int, input().split())
for _ in range(n):
s, f, t = map(int, input().split())
result = t
t_cut = t % (2 * (m - 1))
if s == f:
result = t
elif t_cut >= (m - 1):
if 2 * (m - 1) - t_cut < (s - 1):
result += 2 * (m - 1) - ((s - 1) - (2 * (m - 1) - t_cut))
else:
result += (2 * (m - 1) - t_cut) - (s - 1)
if s < f:
result += (s - 1) + (f - 1)
else:
result += s - f
else:
if t_cut > (s - 1):
result += 2 * (m - 1) - (t_cut - (s - 1))
else:
result += (s - 1) - t_cut
if s < f:
result += f - s
else:
result += 2 * (m - 1) - (s - 1) - (f - 1)
print(result)
``` | instruction | 0 | 43,003 | 8 | 86,006 |
No | output | 1 | 43,003 | 8 | 86,007 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
And now the numerous qualifying tournaments for one of the most prestigious Russian contests Russian Codec Cup are over. All n participants who have made it to the finals found themselves in a huge m-floored 108-star hotel. Of course the first thought to come in a place like this is "How about checking out the elevator?".
The hotel's elevator moves between floors according to one never changing scheme. Initially (at the moment of time 0) the elevator is located on the 1-st floor, then it moves to the 2-nd floor, then — to the 3-rd floor and so on until it reaches the m-th floor. After that the elevator moves to floor m - 1, then to floor m - 2, and so on until it reaches the first floor. This process is repeated infinitely. We know that the elevator has infinite capacity; we also know that on every floor people get on the elevator immediately. Moving between the floors takes a unit of time.
For each of the n participant you are given si, which represents the floor where the i-th participant starts, fi, which represents the floor the i-th participant wants to reach, and ti, which represents the time when the i-th participant starts on the floor si.
For each participant print the minimum time of his/her arrival to the floor fi.
If the elevator stops on the floor si at the time ti, then the i-th participant can enter the elevator immediately. If the participant starts on the floor si and that's the floor he wanted to reach initially (si = fi), then the time of arrival to the floor fi for this participant is considered equal to ti.
Input
The first line contains two space-separated integers n and m (1 ≤ n ≤ 105, 2 ≤ m ≤ 108).
Next n lines contain information about the participants in the form of three space-separated integers si fi ti (1 ≤ si, fi ≤ m, 0 ≤ ti ≤ 108), described in the problem statement.
Output
Print n lines each containing one integer — the time of the arrival for each participant to the required floor.
Examples
Input
7 4
2 4 3
1 2 0
2 2 0
1 2 1
4 3 5
1 2 2
4 2 0
Output
9
1
0
7
10
7
5
Input
5 5
1 5 4
1 3 1
1 3 4
3 1 5
4 2 5
Output
12
10
10
8
7
Note
Let's consider the first sample. The first participant starts at floor s = 2 by the time equal to t = 3. To get to the floor f = 4, he has to wait until the time equals 7, that's the time when the elevator will go upwards for the second time. Then the first participant should get on the elevator and go two floors up. In this case the first participant gets to the floor f at time equal to 9. The second participant starts at the time t = 0 on the floor s = 1, enters the elevator immediately, and arrives to the floor f = 2. The third participant doesn't wait for the elevator, because he needs to arrive to the same floor where he starts.
Submitted Solution:
```
num_people, num_floors = map(int, input().split())
def get_distance(direction, a, b):
if direction == 1:
if a <= b:
return b - a
return 2 * num_floors - a - b
else:
if a >= b:
return a - b
return a + b - 2
for i in range(num_people):
waiting, target, start_time = map(int, input().split())
if waiting == target:
print(start_time)
continue
floor = 1 + start_time % (2 * (num_floors - 1))
#print('waiting: %d, target: %d, start_time: %d' % (waiting, target,
# start_time))
if floor < num_floors:
direction = 1
else:
floor = 2 * num_floors - floor
direction = -1
#print('floor: %d, direction: %d' % (floor, direction))
time = start_time
time += get_distance(direction, floor, waiting)
#print('embark at time %d' % time)
time += get_distance(direction, waiting, target)
#print('disembark at time %d' % time)
print(time)
``` | instruction | 0 | 43,004 | 8 | 86,008 |
No | output | 1 | 43,004 | 8 | 86,009 |
Provide tags and a correct Python 3 solution for this coding contest problem.
Emuskald is a well-known illusionist. One of his trademark tricks involves a set of magical boxes. The essence of the trick is in packing the boxes inside other boxes.
From the top view each magical box looks like a square with side length equal to 2k (k is an integer, k ≥ 0) units. A magical box v can be put inside a magical box u, if side length of v is strictly less than the side length of u. In particular, Emuskald can put 4 boxes of side length 2k - 1 into one box of side length 2k, or as in the following figure:
<image>
Emuskald is about to go on tour performing around the world, and needs to pack his magical boxes for the trip. He has decided that the best way to pack them would be inside another magical box, but magical boxes are quite expensive to make. Help him find the smallest magical box that can fit all his boxes.
Input
The first line of input contains an integer n (1 ≤ n ≤ 105), the number of different sizes of boxes Emuskald has. Each of following n lines contains two integers ki and ai (0 ≤ ki ≤ 109, 1 ≤ ai ≤ 109), which means that Emuskald has ai boxes with side length 2ki. It is guaranteed that all of ki are distinct.
Output
Output a single integer p, such that the smallest magical box that can contain all of Emuskald’s boxes has side length 2p.
Examples
Input
2
0 3
1 5
Output
3
Input
1
0 4
Output
1
Input
2
1 10
2 2
Output
3
Note
Picture explanation. If we have 3 boxes with side length 2 and 5 boxes with side length 1, then we can put all these boxes inside a box with side length 4, for example, as shown in the picture.
In the second test case, we can put all four small boxes into a box with side length 2. | instruction | 0 | 43,284 | 8 | 86,568 |
Tags: greedy, math
Correct Solution:
```
from math import*
n = int(input())
v=0
for i in range(n):
a = [int(x)for x in input().split(' ')]
k = ceil(fabs(log(a[1],4)))
if k==0: k=1
if k+a[0]>v:
v = k+a[0]
print(v)
``` | output | 1 | 43,284 | 8 | 86,569 |
Provide tags and a correct Python 3 solution for this coding contest problem.
Emuskald is a well-known illusionist. One of his trademark tricks involves a set of magical boxes. The essence of the trick is in packing the boxes inside other boxes.
From the top view each magical box looks like a square with side length equal to 2k (k is an integer, k ≥ 0) units. A magical box v can be put inside a magical box u, if side length of v is strictly less than the side length of u. In particular, Emuskald can put 4 boxes of side length 2k - 1 into one box of side length 2k, or as in the following figure:
<image>
Emuskald is about to go on tour performing around the world, and needs to pack his magical boxes for the trip. He has decided that the best way to pack them would be inside another magical box, but magical boxes are quite expensive to make. Help him find the smallest magical box that can fit all his boxes.
Input
The first line of input contains an integer n (1 ≤ n ≤ 105), the number of different sizes of boxes Emuskald has. Each of following n lines contains two integers ki and ai (0 ≤ ki ≤ 109, 1 ≤ ai ≤ 109), which means that Emuskald has ai boxes with side length 2ki. It is guaranteed that all of ki are distinct.
Output
Output a single integer p, such that the smallest magical box that can contain all of Emuskald’s boxes has side length 2p.
Examples
Input
2
0 3
1 5
Output
3
Input
1
0 4
Output
1
Input
2
1 10
2 2
Output
3
Note
Picture explanation. If we have 3 boxes with side length 2 and 5 boxes with side length 1, then we can put all these boxes inside a box with side length 4, for example, as shown in the picture.
In the second test case, we can put all four small boxes into a box with side length 2. | instruction | 0 | 43,286 | 8 | 86,572 |
Tags: greedy, math
Correct Solution:
```
n = int(input())
res = 0
for i in range(n):
h, m = list(map(int, input().split()))
k = 1
r = 4
while m > r:
k += 1
r *= 4
res = max(res, h+k)
print(res)
``` | output | 1 | 43,286 | 8 | 86,573 |
Provide tags and a correct Python 3 solution for this coding contest problem.
Emuskald is a well-known illusionist. One of his trademark tricks involves a set of magical boxes. The essence of the trick is in packing the boxes inside other boxes.
From the top view each magical box looks like a square with side length equal to 2k (k is an integer, k ≥ 0) units. A magical box v can be put inside a magical box u, if side length of v is strictly less than the side length of u. In particular, Emuskald can put 4 boxes of side length 2k - 1 into one box of side length 2k, or as in the following figure:
<image>
Emuskald is about to go on tour performing around the world, and needs to pack his magical boxes for the trip. He has decided that the best way to pack them would be inside another magical box, but magical boxes are quite expensive to make. Help him find the smallest magical box that can fit all his boxes.
Input
The first line of input contains an integer n (1 ≤ n ≤ 105), the number of different sizes of boxes Emuskald has. Each of following n lines contains two integers ki and ai (0 ≤ ki ≤ 109, 1 ≤ ai ≤ 109), which means that Emuskald has ai boxes with side length 2ki. It is guaranteed that all of ki are distinct.
Output
Output a single integer p, such that the smallest magical box that can contain all of Emuskald’s boxes has side length 2p.
Examples
Input
2
0 3
1 5
Output
3
Input
1
0 4
Output
1
Input
2
1 10
2 2
Output
3
Note
Picture explanation. If we have 3 boxes with side length 2 and 5 boxes with side length 1, then we can put all these boxes inside a box with side length 4, for example, as shown in the picture.
In the second test case, we can put all four small boxes into a box with side length 2. | instruction | 0 | 43,287 | 8 | 86,574 |
Tags: greedy, math
Correct Solution:
```
import math
n = int(input())
arr = []
for i in range(n):
k,a = list(map(int,input().split()))
arr.append([k,a])
arr.sort()
ans = 0
for i in arr:
x = math.log(i[1],4)+i[0]
ans = max(ans,math.ceil(x))
if i[1]==1:
ans = max(ans,i[0]+1)
print(ans)
``` | output | 1 | 43,287 | 8 | 86,575 |
Provide tags and a correct Python 3 solution for this coding contest problem.
Emuskald is a well-known illusionist. One of his trademark tricks involves a set of magical boxes. The essence of the trick is in packing the boxes inside other boxes.
From the top view each magical box looks like a square with side length equal to 2k (k is an integer, k ≥ 0) units. A magical box v can be put inside a magical box u, if side length of v is strictly less than the side length of u. In particular, Emuskald can put 4 boxes of side length 2k - 1 into one box of side length 2k, or as in the following figure:
<image>
Emuskald is about to go on tour performing around the world, and needs to pack his magical boxes for the trip. He has decided that the best way to pack them would be inside another magical box, but magical boxes are quite expensive to make. Help him find the smallest magical box that can fit all his boxes.
Input
The first line of input contains an integer n (1 ≤ n ≤ 105), the number of different sizes of boxes Emuskald has. Each of following n lines contains two integers ki and ai (0 ≤ ki ≤ 109, 1 ≤ ai ≤ 109), which means that Emuskald has ai boxes with side length 2ki. It is guaranteed that all of ki are distinct.
Output
Output a single integer p, such that the smallest magical box that can contain all of Emuskald’s boxes has side length 2p.
Examples
Input
2
0 3
1 5
Output
3
Input
1
0 4
Output
1
Input
2
1 10
2 2
Output
3
Note
Picture explanation. If we have 3 boxes with side length 2 and 5 boxes with side length 1, then we can put all these boxes inside a box with side length 4, for example, as shown in the picture.
In the second test case, we can put all four small boxes into a box with side length 2. | instruction | 0 | 43,290 | 8 | 86,580 |
Tags: greedy, math
Correct Solution:
```
from sys import stdin
input = stdin.readline
n = int(input())
res = 0
for i in range(n):
k, a = (int(x) for x in input().split())
if k == 0:
res = max(res, 1)
i = 1
x = 4
while a > x:
i += 1
x *= 4
res = max(res, k + i)
print(res)
``` | output | 1 | 43,290 | 8 | 86,581 |
Provide tags and a correct Python 3 solution for this coding contest problem.
Emuskald is a well-known illusionist. One of his trademark tricks involves a set of magical boxes. The essence of the trick is in packing the boxes inside other boxes.
From the top view each magical box looks like a square with side length equal to 2k (k is an integer, k ≥ 0) units. A magical box v can be put inside a magical box u, if side length of v is strictly less than the side length of u. In particular, Emuskald can put 4 boxes of side length 2k - 1 into one box of side length 2k, or as in the following figure:
<image>
Emuskald is about to go on tour performing around the world, and needs to pack his magical boxes for the trip. He has decided that the best way to pack them would be inside another magical box, but magical boxes are quite expensive to make. Help him find the smallest magical box that can fit all his boxes.
Input
The first line of input contains an integer n (1 ≤ n ≤ 105), the number of different sizes of boxes Emuskald has. Each of following n lines contains two integers ki and ai (0 ≤ ki ≤ 109, 1 ≤ ai ≤ 109), which means that Emuskald has ai boxes with side length 2ki. It is guaranteed that all of ki are distinct.
Output
Output a single integer p, such that the smallest magical box that can contain all of Emuskald’s boxes has side length 2p.
Examples
Input
2
0 3
1 5
Output
3
Input
1
0 4
Output
1
Input
2
1 10
2 2
Output
3
Note
Picture explanation. If we have 3 boxes with side length 2 and 5 boxes with side length 1, then we can put all these boxes inside a box with side length 4, for example, as shown in the picture.
In the second test case, we can put all four small boxes into a box with side length 2. | instruction | 0 | 43,291 | 8 | 86,582 |
Tags: greedy, math
Correct Solution:
```
#------------------------template--------------------------#
import os
import sys
from math import *
from collections import *
from fractions import *
from bisect import *
from heapq import*
from io import BytesIO, IOBase
def vsInput():
sys.stdin = open('input.txt', 'r')
sys.stdout = open('output.txt', 'w')
BUFSIZE = 8192
class FastIO(IOBase):
newlines = 0
def __init__(self, file):
self._fd = file.fileno()
self.buffer = BytesIO()
self.writable = "x" in file.mode or "r" not in file.mode
self.write = self.buffer.write if self.writable else None
def read(self):
while True:
b = os.read(self._fd, max(os.fstat(self._fd).st_size, BUFSIZE))
if not b:
break
ptr = self.buffer.tell()
self.buffer.seek(0, 2), self.buffer.write(b), self.buffer.seek(ptr)
self.newlines = 0
return self.buffer.read()
def readline(self):
while self.newlines == 0:
b = os.read(self._fd, max(os.fstat(self._fd).st_size, BUFSIZE))
self.newlines = b.count(b"\n") + (not b)
ptr = self.buffer.tell()
self.buffer.seek(0, 2), self.buffer.write(b), self.buffer.seek(ptr)
self.newlines -= 1
return self.buffer.readline()
def flush(self):
if self.writable:
os.write(self._fd, self.buffer.getvalue())
self.buffer.truncate(0), self.buffer.seek(0)
class IOWrapper(IOBase):
def __init__(self, file):
self.buffer = FastIO(file)
self.flush = self.buffer.flush
self.writable = self.buffer.writable
self.write = lambda s: self.buffer.write(s.encode("ascii"))
self.read = lambda: self.buffer.read().decode("ascii")
self.readline = lambda: self.buffer.readline().decode("ascii")
sys.stdin, sys.stdout = IOWrapper(sys.stdin), IOWrapper(sys.stdout)
input = lambda: sys.stdin.readline().rstrip("\r\n")
ALPHA='abcdefghijklmnopqrstuvwxyz'
M=1000000007
def value():return tuple(map(int,input().split()))
def array():return [int(i) for i in input().split()]
def Int():return int(input())
def Str():return input()
def arrayS():return [i for i in input().split()]
#-------------------------code---------------------------#
# vsInput()
n=Int()
box=[]
have=defaultdict(int)
for _ in range(n):
p,k=value()
box.append(p)
have[p]=k
box.sort()
ans=0
for i in range(n):
size=box[i]
amount=have[size]
extra=max(1,ceil(log(amount,4)))
ans=max(size+extra,ans)
print(ans)
``` | output | 1 | 43,291 | 8 | 86,583 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
Emuskald is a well-known illusionist. One of his trademark tricks involves a set of magical boxes. The essence of the trick is in packing the boxes inside other boxes.
From the top view each magical box looks like a square with side length equal to 2k (k is an integer, k ≥ 0) units. A magical box v can be put inside a magical box u, if side length of v is strictly less than the side length of u. In particular, Emuskald can put 4 boxes of side length 2k - 1 into one box of side length 2k, or as in the following figure:
<image>
Emuskald is about to go on tour performing around the world, and needs to pack his magical boxes for the trip. He has decided that the best way to pack them would be inside another magical box, but magical boxes are quite expensive to make. Help him find the smallest magical box that can fit all his boxes.
Input
The first line of input contains an integer n (1 ≤ n ≤ 105), the number of different sizes of boxes Emuskald has. Each of following n lines contains two integers ki and ai (0 ≤ ki ≤ 109, 1 ≤ ai ≤ 109), which means that Emuskald has ai boxes with side length 2ki. It is guaranteed that all of ki are distinct.
Output
Output a single integer p, such that the smallest magical box that can contain all of Emuskald’s boxes has side length 2p.
Examples
Input
2
0 3
1 5
Output
3
Input
1
0 4
Output
1
Input
2
1 10
2 2
Output
3
Note
Picture explanation. If we have 3 boxes with side length 2 and 5 boxes with side length 1, then we can put all these boxes inside a box with side length 4, for example, as shown in the picture.
In the second test case, we can put all four small boxes into a box with side length 2.
Submitted Solution:
```
import math as m
r=0
for _ in range(int(input())):
k,a=[int(x) for x in input().split()]
e=0;v=1
while v<a: v*=4;e+=1
if e+k>r: r=e+k
if k+1>r: r=k+1
print(r)
# Made By Mostafa_Khaled
``` | instruction | 0 | 43,292 | 8 | 86,584 |
Yes | output | 1 | 43,292 | 8 | 86,585 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
Emuskald is a well-known illusionist. One of his trademark tricks involves a set of magical boxes. The essence of the trick is in packing the boxes inside other boxes.
From the top view each magical box looks like a square with side length equal to 2k (k is an integer, k ≥ 0) units. A magical box v can be put inside a magical box u, if side length of v is strictly less than the side length of u. In particular, Emuskald can put 4 boxes of side length 2k - 1 into one box of side length 2k, or as in the following figure:
<image>
Emuskald is about to go on tour performing around the world, and needs to pack his magical boxes for the trip. He has decided that the best way to pack them would be inside another magical box, but magical boxes are quite expensive to make. Help him find the smallest magical box that can fit all his boxes.
Input
The first line of input contains an integer n (1 ≤ n ≤ 105), the number of different sizes of boxes Emuskald has. Each of following n lines contains two integers ki and ai (0 ≤ ki ≤ 109, 1 ≤ ai ≤ 109), which means that Emuskald has ai boxes with side length 2ki. It is guaranteed that all of ki are distinct.
Output
Output a single integer p, such that the smallest magical box that can contain all of Emuskald’s boxes has side length 2p.
Examples
Input
2
0 3
1 5
Output
3
Input
1
0 4
Output
1
Input
2
1 10
2 2
Output
3
Note
Picture explanation. If we have 3 boxes with side length 2 and 5 boxes with side length 1, then we can put all these boxes inside a box with side length 4, for example, as shown in the picture.
In the second test case, we can put all four small boxes into a box with side length 2.
Submitted Solution:
```
import math as m
r=0
for _ in range(int(input())):
k,a=[int(x) for x in input().split()]
e=0;v=1
while v<a: v*=4;e+=1
if e+k>r: r=e+k
if k+1>r: r=k+1
print(r)
``` | instruction | 0 | 43,293 | 8 | 86,586 |
Yes | output | 1 | 43,293 | 8 | 86,587 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
Emuskald is a well-known illusionist. One of his trademark tricks involves a set of magical boxes. The essence of the trick is in packing the boxes inside other boxes.
From the top view each magical box looks like a square with side length equal to 2k (k is an integer, k ≥ 0) units. A magical box v can be put inside a magical box u, if side length of v is strictly less than the side length of u. In particular, Emuskald can put 4 boxes of side length 2k - 1 into one box of side length 2k, or as in the following figure:
<image>
Emuskald is about to go on tour performing around the world, and needs to pack his magical boxes for the trip. He has decided that the best way to pack them would be inside another magical box, but magical boxes are quite expensive to make. Help him find the smallest magical box that can fit all his boxes.
Input
The first line of input contains an integer n (1 ≤ n ≤ 105), the number of different sizes of boxes Emuskald has. Each of following n lines contains two integers ki and ai (0 ≤ ki ≤ 109, 1 ≤ ai ≤ 109), which means that Emuskald has ai boxes with side length 2ki. It is guaranteed that all of ki are distinct.
Output
Output a single integer p, such that the smallest magical box that can contain all of Emuskald’s boxes has side length 2p.
Examples
Input
2
0 3
1 5
Output
3
Input
1
0 4
Output
1
Input
2
1 10
2 2
Output
3
Note
Picture explanation. If we have 3 boxes with side length 2 and 5 boxes with side length 1, then we can put all these boxes inside a box with side length 4, for example, as shown in the picture.
In the second test case, we can put all four small boxes into a box with side length 2.
Submitted Solution:
```
import math
n,o=int(input()),0
for i in range(n):
r,t=map(int,input().split())
r+=math.ceil(math.log(t,4))
r+=t==1
o=max(o,r)
print(o)
``` | instruction | 0 | 43,294 | 8 | 86,588 |
Yes | output | 1 | 43,294 | 8 | 86,589 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
Emuskald is a well-known illusionist. One of his trademark tricks involves a set of magical boxes. The essence of the trick is in packing the boxes inside other boxes.
From the top view each magical box looks like a square with side length equal to 2k (k is an integer, k ≥ 0) units. A magical box v can be put inside a magical box u, if side length of v is strictly less than the side length of u. In particular, Emuskald can put 4 boxes of side length 2k - 1 into one box of side length 2k, or as in the following figure:
<image>
Emuskald is about to go on tour performing around the world, and needs to pack his magical boxes for the trip. He has decided that the best way to pack them would be inside another magical box, but magical boxes are quite expensive to make. Help him find the smallest magical box that can fit all his boxes.
Input
The first line of input contains an integer n (1 ≤ n ≤ 105), the number of different sizes of boxes Emuskald has. Each of following n lines contains two integers ki and ai (0 ≤ ki ≤ 109, 1 ≤ ai ≤ 109), which means that Emuskald has ai boxes with side length 2ki. It is guaranteed that all of ki are distinct.
Output
Output a single integer p, such that the smallest magical box that can contain all of Emuskald’s boxes has side length 2p.
Examples
Input
2
0 3
1 5
Output
3
Input
1
0 4
Output
1
Input
2
1 10
2 2
Output
3
Note
Picture explanation. If we have 3 boxes with side length 2 and 5 boxes with side length 1, then we can put all these boxes inside a box with side length 4, for example, as shown in the picture.
In the second test case, we can put all four small boxes into a box with side length 2.
Submitted Solution:
```
from math import *
n,o=int(input()),0
for i in range(n):
r,t=map(int,input().split())
r+=ceil(log(t,4))
r+=t==1
o=max(o,r)
print(o)
``` | instruction | 0 | 43,295 | 8 | 86,590 |
Yes | output | 1 | 43,295 | 8 | 86,591 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
Emuskald is a well-known illusionist. One of his trademark tricks involves a set of magical boxes. The essence of the trick is in packing the boxes inside other boxes.
From the top view each magical box looks like a square with side length equal to 2k (k is an integer, k ≥ 0) units. A magical box v can be put inside a magical box u, if side length of v is strictly less than the side length of u. In particular, Emuskald can put 4 boxes of side length 2k - 1 into one box of side length 2k, or as in the following figure:
<image>
Emuskald is about to go on tour performing around the world, and needs to pack his magical boxes for the trip. He has decided that the best way to pack them would be inside another magical box, but magical boxes are quite expensive to make. Help him find the smallest magical box that can fit all his boxes.
Input
The first line of input contains an integer n (1 ≤ n ≤ 105), the number of different sizes of boxes Emuskald has. Each of following n lines contains two integers ki and ai (0 ≤ ki ≤ 109, 1 ≤ ai ≤ 109), which means that Emuskald has ai boxes with side length 2ki. It is guaranteed that all of ki are distinct.
Output
Output a single integer p, such that the smallest magical box that can contain all of Emuskald’s boxes has side length 2p.
Examples
Input
2
0 3
1 5
Output
3
Input
1
0 4
Output
1
Input
2
1 10
2 2
Output
3
Note
Picture explanation. If we have 3 boxes with side length 2 and 5 boxes with side length 1, then we can put all these boxes inside a box with side length 4, for example, as shown in the picture.
In the second test case, we can put all four small boxes into a box with side length 2.
Submitted Solution:
```
# Solution to CodeForces 269A Magic Boxes
from math import ceil
from collections import defaultdict
n = int(input()) # Number of sizes
sizes = defaultdict(int)
for _ in range(n):
k, a = map(int, input().strip().split())
sizes[k] = a # There are a boxes of size k
ki = 0
while True:
# ki + 1 boxes needed to contain
sizes[ki + 1] = max(sizes[ki + 1], ceil(sizes[ki] / 4))
ki += 1
if ((ki > n) and (sizes[ki] == 1) and (ki + 1 not in sizes)):
break
print(ki)
``` | instruction | 0 | 43,296 | 8 | 86,592 |
No | output | 1 | 43,296 | 8 | 86,593 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
Emuskald is a well-known illusionist. One of his trademark tricks involves a set of magical boxes. The essence of the trick is in packing the boxes inside other boxes.
From the top view each magical box looks like a square with side length equal to 2k (k is an integer, k ≥ 0) units. A magical box v can be put inside a magical box u, if side length of v is strictly less than the side length of u. In particular, Emuskald can put 4 boxes of side length 2k - 1 into one box of side length 2k, or as in the following figure:
<image>
Emuskald is about to go on tour performing around the world, and needs to pack his magical boxes for the trip. He has decided that the best way to pack them would be inside another magical box, but magical boxes are quite expensive to make. Help him find the smallest magical box that can fit all his boxes.
Input
The first line of input contains an integer n (1 ≤ n ≤ 105), the number of different sizes of boxes Emuskald has. Each of following n lines contains two integers ki and ai (0 ≤ ki ≤ 109, 1 ≤ ai ≤ 109), which means that Emuskald has ai boxes with side length 2ki. It is guaranteed that all of ki are distinct.
Output
Output a single integer p, such that the smallest magical box that can contain all of Emuskald’s boxes has side length 2p.
Examples
Input
2
0 3
1 5
Output
3
Input
1
0 4
Output
1
Input
2
1 10
2 2
Output
3
Note
Picture explanation. If we have 3 boxes with side length 2 and 5 boxes with side length 1, then we can put all these boxes inside a box with side length 4, for example, as shown in the picture.
In the second test case, we can put all four small boxes into a box with side length 2.
Submitted Solution:
```
import math as m
p=[]
for _ in range(int(input())):
k,a=[int(x) for x in input().split()]
e=0;v=1
while v<a: v*=4;e+=1
p+=[e+k]
print(max(k+1,*p))
``` | instruction | 0 | 43,297 | 8 | 86,594 |
No | output | 1 | 43,297 | 8 | 86,595 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
Emuskald is a well-known illusionist. One of his trademark tricks involves a set of magical boxes. The essence of the trick is in packing the boxes inside other boxes.
From the top view each magical box looks like a square with side length equal to 2k (k is an integer, k ≥ 0) units. A magical box v can be put inside a magical box u, if side length of v is strictly less than the side length of u. In particular, Emuskald can put 4 boxes of side length 2k - 1 into one box of side length 2k, or as in the following figure:
<image>
Emuskald is about to go on tour performing around the world, and needs to pack his magical boxes for the trip. He has decided that the best way to pack them would be inside another magical box, but magical boxes are quite expensive to make. Help him find the smallest magical box that can fit all his boxes.
Input
The first line of input contains an integer n (1 ≤ n ≤ 105), the number of different sizes of boxes Emuskald has. Each of following n lines contains two integers ki and ai (0 ≤ ki ≤ 109, 1 ≤ ai ≤ 109), which means that Emuskald has ai boxes with side length 2ki. It is guaranteed that all of ki are distinct.
Output
Output a single integer p, such that the smallest magical box that can contain all of Emuskald’s boxes has side length 2p.
Examples
Input
2
0 3
1 5
Output
3
Input
1
0 4
Output
1
Input
2
1 10
2 2
Output
3
Note
Picture explanation. If we have 3 boxes with side length 2 and 5 boxes with side length 1, then we can put all these boxes inside a box with side length 4, for example, as shown in the picture.
In the second test case, we can put all four small boxes into a box with side length 2.
Submitted Solution:
```
import math
n = int(input())
arr = []
for i in range(n):
k,a = list(map(int,input().split()))
arr.append([k,a])
arr.sort()
ans = -1
for i in arr:
x = math.log(i[1],4)+i[0]
ans = max(ans,math.ceil(x))
print(ans)
``` | instruction | 0 | 43,298 | 8 | 86,596 |
No | output | 1 | 43,298 | 8 | 86,597 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
Emuskald is a well-known illusionist. One of his trademark tricks involves a set of magical boxes. The essence of the trick is in packing the boxes inside other boxes.
From the top view each magical box looks like a square with side length equal to 2k (k is an integer, k ≥ 0) units. A magical box v can be put inside a magical box u, if side length of v is strictly less than the side length of u. In particular, Emuskald can put 4 boxes of side length 2k - 1 into one box of side length 2k, or as in the following figure:
<image>
Emuskald is about to go on tour performing around the world, and needs to pack his magical boxes for the trip. He has decided that the best way to pack them would be inside another magical box, but magical boxes are quite expensive to make. Help him find the smallest magical box that can fit all his boxes.
Input
The first line of input contains an integer n (1 ≤ n ≤ 105), the number of different sizes of boxes Emuskald has. Each of following n lines contains two integers ki and ai (0 ≤ ki ≤ 109, 1 ≤ ai ≤ 109), which means that Emuskald has ai boxes with side length 2ki. It is guaranteed that all of ki are distinct.
Output
Output a single integer p, such that the smallest magical box that can contain all of Emuskald’s boxes has side length 2p.
Examples
Input
2
0 3
1 5
Output
3
Input
1
0 4
Output
1
Input
2
1 10
2 2
Output
3
Note
Picture explanation. If we have 3 boxes with side length 2 and 5 boxes with side length 1, then we can put all these boxes inside a box with side length 4, for example, as shown in the picture.
In the second test case, we can put all four small boxes into a box with side length 2.
Submitted Solution:
```
import math as m
p=[]
for _ in range(int(input())):
k,a=[int(x) for x in input().split()]
p+=[m.ceil(m.log(a,4))+k]
print(max(p))
``` | instruction | 0 | 43,299 | 8 | 86,598 |
No | output | 1 | 43,299 | 8 | 86,599 |
Provide tags and a correct Python 3 solution for this coding contest problem.
Imagine that you are in a building that has exactly n floors. You can move between the floors in a lift. Let's number the floors from bottom to top with integers from 1 to n. Now you're on the floor number a. You are very bored, so you want to take the lift. Floor number b has a secret lab, the entry is forbidden. However, you already are in the mood and decide to make k consecutive trips in the lift.
Let us suppose that at the moment you are on the floor number x (initially, you were on floor a). For another trip between floors you choose some floor with number y (y ≠ x) and the lift travels to this floor. As you cannot visit floor b with the secret lab, you decided that the distance from the current floor x to the chosen y must be strictly less than the distance from the current floor x to floor b with the secret lab. Formally, it means that the following inequation must fulfill: |x - y| < |x - b|. After the lift successfully transports you to floor y, you write down number y in your notepad.
Your task is to find the number of distinct number sequences that you could have written in the notebook as the result of k trips in the lift. As the sought number of trips can be rather large, find the remainder after dividing the number by 1000000007 (109 + 7).
Input
The first line of the input contains four space-separated integers n, a, b, k (2 ≤ n ≤ 5000, 1 ≤ k ≤ 5000, 1 ≤ a, b ≤ n, a ≠ b).
Output
Print a single integer — the remainder after dividing the sought number of sequences by 1000000007 (109 + 7).
Examples
Input
5 2 4 1
Output
2
Input
5 2 4 2
Output
2
Input
5 3 4 1
Output
0
Note
Two sequences p1, p2, ..., pk and q1, q2, ..., qk are distinct, if there is such integer j (1 ≤ j ≤ k), that pj ≠ qj.
Notes to the samples:
1. In the first sample after the first trip you are either on floor 1, or on floor 3, because |1 - 2| < |2 - 4| and |3 - 2| < |2 - 4|.
2. In the second sample there are two possible sequences: (1, 2); (1, 3). You cannot choose floor 3 for the first trip because in this case no floor can be the floor for the second trip.
3. In the third sample there are no sought sequences, because you cannot choose the floor for the first trip. | instruction | 0 | 43,360 | 8 | 86,720 |
Tags: combinatorics, dp
Correct Solution:
```
def solve(n, st, k):
MOD = int(1e9 + 7)
dp = [0] * (n + 1)
prefix_sum = [0] * (n + 1)
dp[st] = 1
for times in range(k):
prefix_sum[0] = 0
for i in range(1, n + 1):
prefix_sum[i] = prefix_sum[i - 1] + dp[i]
if prefix_sum[i] >= MOD: prefix_sum[i] -= MOD
for i in range(1, n + 1):
t = prefix_sum[n] - prefix_sum[i] + prefix_sum[i - 1] - prefix_sum[i >> 1]
while t < 0: t += MOD
while t >= MOD: t -= MOD
dp[i] = t
return sum(dp) % MOD
def main():
n, a, b, k = [int(i) for i in input().split()]
if a > b:
print(solve(n - b, a - b, k))
else:
print(solve(b - 1, b - a, k))
main()
``` | output | 1 | 43,360 | 8 | 86,721 |
Provide tags and a correct Python 3 solution for this coding contest problem.
Imagine that you are in a building that has exactly n floors. You can move between the floors in a lift. Let's number the floors from bottom to top with integers from 1 to n. Now you're on the floor number a. You are very bored, so you want to take the lift. Floor number b has a secret lab, the entry is forbidden. However, you already are in the mood and decide to make k consecutive trips in the lift.
Let us suppose that at the moment you are on the floor number x (initially, you were on floor a). For another trip between floors you choose some floor with number y (y ≠ x) and the lift travels to this floor. As you cannot visit floor b with the secret lab, you decided that the distance from the current floor x to the chosen y must be strictly less than the distance from the current floor x to floor b with the secret lab. Formally, it means that the following inequation must fulfill: |x - y| < |x - b|. After the lift successfully transports you to floor y, you write down number y in your notepad.
Your task is to find the number of distinct number sequences that you could have written in the notebook as the result of k trips in the lift. As the sought number of trips can be rather large, find the remainder after dividing the number by 1000000007 (109 + 7).
Input
The first line of the input contains four space-separated integers n, a, b, k (2 ≤ n ≤ 5000, 1 ≤ k ≤ 5000, 1 ≤ a, b ≤ n, a ≠ b).
Output
Print a single integer — the remainder after dividing the sought number of sequences by 1000000007 (109 + 7).
Examples
Input
5 2 4 1
Output
2
Input
5 2 4 2
Output
2
Input
5 3 4 1
Output
0
Note
Two sequences p1, p2, ..., pk and q1, q2, ..., qk are distinct, if there is such integer j (1 ≤ j ≤ k), that pj ≠ qj.
Notes to the samples:
1. In the first sample after the first trip you are either on floor 1, or on floor 3, because |1 - 2| < |2 - 4| and |3 - 2| < |2 - 4|.
2. In the second sample there are two possible sequences: (1, 2); (1, 3). You cannot choose floor 3 for the first trip because in this case no floor can be the floor for the second trip.
3. In the third sample there are no sought sequences, because you cannot choose the floor for the first trip. | instruction | 0 | 43,361 | 8 | 86,722 |
Tags: combinatorics, dp
Correct Solution:
```
n,a,b,k=map(int,input().split())
dp=[[0 for i in range(n+2)] for j in range(2)]
dp[0][a]=1
now=1
last=0
mod=1000000007
for i in range(k):
for j in range(1,n+1):
d=max(abs(j-b)-1,0)
if j!=n:
dp[now][j+1]=(dp[last][j]+dp[now][j+1])%mod
dp[now][min(j+d+1,n+1)]=(dp[now][min(j+d+1,n+1)]-dp[last][j])%mod
if j!=1:
dp[now][j]=(dp[now][j]-dp[last][j])%mod
dp[now][max(j-d,1)]=(dp[now][max(j-d,1)]+dp[last][j])%mod
for i1 in range(1,n+2):
dp[now][i1]=(dp[now][i1]+dp[now][i1-1])%mod
dp[last][i1]=0
aux=now
now=last
last=aux
print(sum(dp[last])%mod)
``` | output | 1 | 43,361 | 8 | 86,723 |
Provide tags and a correct Python 3 solution for this coding contest problem.
Imagine that you are in a building that has exactly n floors. You can move between the floors in a lift. Let's number the floors from bottom to top with integers from 1 to n. Now you're on the floor number a. You are very bored, so you want to take the lift. Floor number b has a secret lab, the entry is forbidden. However, you already are in the mood and decide to make k consecutive trips in the lift.
Let us suppose that at the moment you are on the floor number x (initially, you were on floor a). For another trip between floors you choose some floor with number y (y ≠ x) and the lift travels to this floor. As you cannot visit floor b with the secret lab, you decided that the distance from the current floor x to the chosen y must be strictly less than the distance from the current floor x to floor b with the secret lab. Formally, it means that the following inequation must fulfill: |x - y| < |x - b|. After the lift successfully transports you to floor y, you write down number y in your notepad.
Your task is to find the number of distinct number sequences that you could have written in the notebook as the result of k trips in the lift. As the sought number of trips can be rather large, find the remainder after dividing the number by 1000000007 (109 + 7).
Input
The first line of the input contains four space-separated integers n, a, b, k (2 ≤ n ≤ 5000, 1 ≤ k ≤ 5000, 1 ≤ a, b ≤ n, a ≠ b).
Output
Print a single integer — the remainder after dividing the sought number of sequences by 1000000007 (109 + 7).
Examples
Input
5 2 4 1
Output
2
Input
5 2 4 2
Output
2
Input
5 3 4 1
Output
0
Note
Two sequences p1, p2, ..., pk and q1, q2, ..., qk are distinct, if there is such integer j (1 ≤ j ≤ k), that pj ≠ qj.
Notes to the samples:
1. In the first sample after the first trip you are either on floor 1, or on floor 3, because |1 - 2| < |2 - 4| and |3 - 2| < |2 - 4|.
2. In the second sample there are two possible sequences: (1, 2); (1, 3). You cannot choose floor 3 for the first trip because in this case no floor can be the floor for the second trip.
3. In the third sample there are no sought sequences, because you cannot choose the floor for the first trip. | instruction | 0 | 43,362 | 8 | 86,724 |
Tags: combinatorics, dp
Correct Solution:
```
#!/usr/bin/env python3
import io
import os
import sys
input = io.BytesIO(os.read(0,os.fstat(0).st_size)).readline
def printd(*args, **kwargs):
#print(*args, **kwargs, file=sys.stderr)
#print(*args, **kwargs)
pass
def get_str():
return input().decode().strip()
def rint():
return map(int, input().split())
def oint():
return int(input())
mod = 1000000007
n, a, b, k = rint()
if a > b:
a, b = n-a+1, n-b+1
a -= 1
b -= 1
printd(n, a, b, k)
d = [0]*n
d[a] = 1
ps = [0]*b
ps[0] = d[0]
for j in range(1, b):
ps[j] = ps[j-1]+d[j]
while ps[j] > mod:
ps[j] -= mod
ps[j] %= mod
printd(n, a, b, k)
printd(d, ps)
for i in range(k):
for j in range(b):
#b-t > t-j
#2*t < b+j
#t < (b+j)/2
if (b+j)%2:
t = (b+j)//2
else:
t = (b+j)//2 - 1
if j == 0:
d[j] = ps[t] - ps[j]
else:
d[j] = ps[t] - ps[j] + ps[j-1]
while d[j] > mod:
d[j] -= mod
while d[j] <0:
d[j] += mod
d[j] %= mod
#d[j] %=mod
ps[0] = d[0]
for j in range(1, b):
ps[j] = (ps[j-1]+d[j])# %mod
while ps[j] > mod:
ps[j] -= mod
while ps[j] < 0:
ps[j] += mod
ps[j] %= mod
printd(d,ps)
ans = ps[b-1]
print(ans%mod)
``` | output | 1 | 43,362 | 8 | 86,725 |
Provide tags and a correct Python 3 solution for this coding contest problem.
Imagine that you are in a building that has exactly n floors. You can move between the floors in a lift. Let's number the floors from bottom to top with integers from 1 to n. Now you're on the floor number a. You are very bored, so you want to take the lift. Floor number b has a secret lab, the entry is forbidden. However, you already are in the mood and decide to make k consecutive trips in the lift.
Let us suppose that at the moment you are on the floor number x (initially, you were on floor a). For another trip between floors you choose some floor with number y (y ≠ x) and the lift travels to this floor. As you cannot visit floor b with the secret lab, you decided that the distance from the current floor x to the chosen y must be strictly less than the distance from the current floor x to floor b with the secret lab. Formally, it means that the following inequation must fulfill: |x - y| < |x - b|. After the lift successfully transports you to floor y, you write down number y in your notepad.
Your task is to find the number of distinct number sequences that you could have written in the notebook as the result of k trips in the lift. As the sought number of trips can be rather large, find the remainder after dividing the number by 1000000007 (109 + 7).
Input
The first line of the input contains four space-separated integers n, a, b, k (2 ≤ n ≤ 5000, 1 ≤ k ≤ 5000, 1 ≤ a, b ≤ n, a ≠ b).
Output
Print a single integer — the remainder after dividing the sought number of sequences by 1000000007 (109 + 7).
Examples
Input
5 2 4 1
Output
2
Input
5 2 4 2
Output
2
Input
5 3 4 1
Output
0
Note
Two sequences p1, p2, ..., pk and q1, q2, ..., qk are distinct, if there is such integer j (1 ≤ j ≤ k), that pj ≠ qj.
Notes to the samples:
1. In the first sample after the first trip you are either on floor 1, or on floor 3, because |1 - 2| < |2 - 4| and |3 - 2| < |2 - 4|.
2. In the second sample there are two possible sequences: (1, 2); (1, 3). You cannot choose floor 3 for the first trip because in this case no floor can be the floor for the second trip.
3. In the third sample there are no sought sequences, because you cannot choose the floor for the first trip. | instruction | 0 | 43,363 | 8 | 86,726 |
Tags: combinatorics, dp
Correct Solution:
```
from sys import stdin
#parser
def parser():
return map(int, stdin.readline().split())
mod=pow(10,9)+7
n,a,b,k=parser()
if a>b:
a=n-a+1
n=n-b
b=n+1
else:
n=b-1
prefix_sum=[0 for x in range(n+1)]
secuences=[0 for x in range(n+1)]
secuences[a]=1
for i in range(k):
prefix_sum[0]=secuences[0]
for j in range(1,n+1):
prefix_sum[j]=prefix_sum[j-1]+secuences[j]
prefix_sum[j]%=mod
for j in range(1,n+1):
distance=b-j
mid_distance=0
if distance % 2 == 0:
mid_distance=distance//2-1
else:
mid_distance=distance//2
secuences[j]=prefix_sum[j-1]+prefix_sum[j+mid_distance]-prefix_sum[j]
secuences[j]%=mod
print(sum(secuences)%mod)
``` | output | 1 | 43,363 | 8 | 86,727 |
Provide tags and a correct Python 3 solution for this coding contest problem.
Imagine that you are in a building that has exactly n floors. You can move between the floors in a lift. Let's number the floors from bottom to top with integers from 1 to n. Now you're on the floor number a. You are very bored, so you want to take the lift. Floor number b has a secret lab, the entry is forbidden. However, you already are in the mood and decide to make k consecutive trips in the lift.
Let us suppose that at the moment you are on the floor number x (initially, you were on floor a). For another trip between floors you choose some floor with number y (y ≠ x) and the lift travels to this floor. As you cannot visit floor b with the secret lab, you decided that the distance from the current floor x to the chosen y must be strictly less than the distance from the current floor x to floor b with the secret lab. Formally, it means that the following inequation must fulfill: |x - y| < |x - b|. After the lift successfully transports you to floor y, you write down number y in your notepad.
Your task is to find the number of distinct number sequences that you could have written in the notebook as the result of k trips in the lift. As the sought number of trips can be rather large, find the remainder after dividing the number by 1000000007 (109 + 7).
Input
The first line of the input contains four space-separated integers n, a, b, k (2 ≤ n ≤ 5000, 1 ≤ k ≤ 5000, 1 ≤ a, b ≤ n, a ≠ b).
Output
Print a single integer — the remainder after dividing the sought number of sequences by 1000000007 (109 + 7).
Examples
Input
5 2 4 1
Output
2
Input
5 2 4 2
Output
2
Input
5 3 4 1
Output
0
Note
Two sequences p1, p2, ..., pk and q1, q2, ..., qk are distinct, if there is such integer j (1 ≤ j ≤ k), that pj ≠ qj.
Notes to the samples:
1. In the first sample after the first trip you are either on floor 1, or on floor 3, because |1 - 2| < |2 - 4| and |3 - 2| < |2 - 4|.
2. In the second sample there are two possible sequences: (1, 2); (1, 3). You cannot choose floor 3 for the first trip because in this case no floor can be the floor for the second trip.
3. In the third sample there are no sought sequences, because you cannot choose the floor for the first trip. | instruction | 0 | 43,364 | 8 | 86,728 |
Tags: combinatorics, dp
Correct Solution:
```
#!/usr/bin/env python3
import io
import os
import sys
input = io.BytesIO(os.read(0,os.fstat(0).st_size)).readline
def printd(*args, **kwargs):
#print(*args, **kwargs, file=sys.stderr)
#print(*args, **kwargs)
pass
def get_str():
return input().decode().strip()
def rint():
return map(int, input().split())
def oint():
return int(input())
mod = 1000000007
n, a, b, k = rint()
if a > b:
a, b = n-a+1, n-b+1
a -= 1
b -= 1
printd(n, a, b, k)
d = [0]*n
d[a] = 1
ps = [0]*b
ps[0] = d[0]
for j in range(1, b):
ps[j] = ps[j-1]+d[j]
ps[j] %= mod
while ps[j] > mod:
ps[j] -= mod
printd(n, a, b, k)
printd(d, ps)
for i in range(k):
for j in range(b):
#b-t > t-j
#2*t < b+j
#t < (b+j)/2
if (b+j)%2:
t = (b+j)//2
else:
t = (b+j)//2 - 1
if j == 0:
d[j] = ps[t] - ps[j]
else:
d[j] = ps[t] - ps[j] + ps[j-1]
d[j] %= mod
while d[j] > mod:
d[j] -= mod
while d[j] <0:
d[j] += mod
#d[j] %=mod
ps[0] = d[0]
for j in range(1, b):
ps[j] = (ps[j-1]+d[j])# %mod
ps[j] %= mod
while ps[j] > mod:
ps[j] -= mod
while ps[j] < 0:
ps[j] += mod
printd(d,ps)
ans = ps[b-1]
print(ans%mod)
``` | output | 1 | 43,364 | 8 | 86,729 |
Provide tags and a correct Python 3 solution for this coding contest problem.
Imagine that you are in a building that has exactly n floors. You can move between the floors in a lift. Let's number the floors from bottom to top with integers from 1 to n. Now you're on the floor number a. You are very bored, so you want to take the lift. Floor number b has a secret lab, the entry is forbidden. However, you already are in the mood and decide to make k consecutive trips in the lift.
Let us suppose that at the moment you are on the floor number x (initially, you were on floor a). For another trip between floors you choose some floor with number y (y ≠ x) and the lift travels to this floor. As you cannot visit floor b with the secret lab, you decided that the distance from the current floor x to the chosen y must be strictly less than the distance from the current floor x to floor b with the secret lab. Formally, it means that the following inequation must fulfill: |x - y| < |x - b|. After the lift successfully transports you to floor y, you write down number y in your notepad.
Your task is to find the number of distinct number sequences that you could have written in the notebook as the result of k trips in the lift. As the sought number of trips can be rather large, find the remainder after dividing the number by 1000000007 (109 + 7).
Input
The first line of the input contains four space-separated integers n, a, b, k (2 ≤ n ≤ 5000, 1 ≤ k ≤ 5000, 1 ≤ a, b ≤ n, a ≠ b).
Output
Print a single integer — the remainder after dividing the sought number of sequences by 1000000007 (109 + 7).
Examples
Input
5 2 4 1
Output
2
Input
5 2 4 2
Output
2
Input
5 3 4 1
Output
0
Note
Two sequences p1, p2, ..., pk and q1, q2, ..., qk are distinct, if there is such integer j (1 ≤ j ≤ k), that pj ≠ qj.
Notes to the samples:
1. In the first sample after the first trip you are either on floor 1, or on floor 3, because |1 - 2| < |2 - 4| and |3 - 2| < |2 - 4|.
2. In the second sample there are two possible sequences: (1, 2); (1, 3). You cannot choose floor 3 for the first trip because in this case no floor can be the floor for the second trip.
3. In the third sample there are no sought sequences, because you cannot choose the floor for the first trip. | instruction | 0 | 43,365 | 8 | 86,730 |
Tags: combinatorics, dp
Correct Solution:
```
# -*- coding:utf-8 -*-
"""
created by shuangquan.huang at 1/17/20
"""
import collections
import time
import os
import sys
import bisect
import heapq
from typing import List
def solve(N, A, B, K):
MOD = 1000000007
dp = [0 for _ in range(N+1)]
dp[A] = 1
for k in range(1, K+1):
ndp = [0 for _ in range(N+1)]
for x in range(1, N+1):
d = abs(x-B)
if d <= 1:
continue
l, r = max(x-d+1, 1), min(x+d, N+1)
if l < x:
ndp[l] = (ndp[l] + dp[x]) % MOD
ndp[x] = (ndp[x] - dp[x]) % MOD
if x < r:
if x + 1 <= N:
ndp[x+1] = (ndp[x+1] + dp[x]) % MOD
if r <= N:
ndp[r] = (ndp[r] - dp[x]) % MOD
v = 0
for x in range(N+1):
v += ndp[x]
v %= MOD
ndp[x] = v
dp = ndp
return sum(dp) % MOD
N, A, B, K = map(int, input().split())
print(solve(N, A, B, K))
``` | output | 1 | 43,365 | 8 | 86,731 |
Provide tags and a correct Python 3 solution for this coding contest problem.
Imagine that you are in a building that has exactly n floors. You can move between the floors in a lift. Let's number the floors from bottom to top with integers from 1 to n. Now you're on the floor number a. You are very bored, so you want to take the lift. Floor number b has a secret lab, the entry is forbidden. However, you already are in the mood and decide to make k consecutive trips in the lift.
Let us suppose that at the moment you are on the floor number x (initially, you were on floor a). For another trip between floors you choose some floor with number y (y ≠ x) and the lift travels to this floor. As you cannot visit floor b with the secret lab, you decided that the distance from the current floor x to the chosen y must be strictly less than the distance from the current floor x to floor b with the secret lab. Formally, it means that the following inequation must fulfill: |x - y| < |x - b|. After the lift successfully transports you to floor y, you write down number y in your notepad.
Your task is to find the number of distinct number sequences that you could have written in the notebook as the result of k trips in the lift. As the sought number of trips can be rather large, find the remainder after dividing the number by 1000000007 (109 + 7).
Input
The first line of the input contains four space-separated integers n, a, b, k (2 ≤ n ≤ 5000, 1 ≤ k ≤ 5000, 1 ≤ a, b ≤ n, a ≠ b).
Output
Print a single integer — the remainder after dividing the sought number of sequences by 1000000007 (109 + 7).
Examples
Input
5 2 4 1
Output
2
Input
5 2 4 2
Output
2
Input
5 3 4 1
Output
0
Note
Two sequences p1, p2, ..., pk and q1, q2, ..., qk are distinct, if there is such integer j (1 ≤ j ≤ k), that pj ≠ qj.
Notes to the samples:
1. In the first sample after the first trip you are either on floor 1, or on floor 3, because |1 - 2| < |2 - 4| and |3 - 2| < |2 - 4|.
2. In the second sample there are two possible sequences: (1, 2); (1, 3). You cannot choose floor 3 for the first trip because in this case no floor can be the floor for the second trip.
3. In the third sample there are no sought sequences, because you cannot choose the floor for the first trip. | instruction | 0 | 43,366 | 8 | 86,732 |
Tags: combinatorics, dp
Correct Solution:
```
def solve(n, st, k):
MOD = int(1e9 + 7)
prev = [0] * (n + 1)
current = [0] * (n + 1)
prefix_sum = [0] * (n + 1)
prev[st] = 1
for times in range(k):
prefix_sum[0] = 0
for i in range(1, n + 1):
prefix_sum[i] = prefix_sum[i - 1] + prev[i]
if prefix_sum[i] >= MOD:
prefix_sum[i] -= MOD
for i in range(1, n + 1):
current[i] = prefix_sum[n] - prefix_sum[i >> 1] - prev[i]
while current[i] < 0: current[i] += MOD
while current[i] >= MOD: current[i] -= MOD
prev, current = current, prev
return sum(prev) % MOD
def main():
n, a, b, k = [int(i) for i in input().split()]
if a > b:
print(solve(n - b, a - b, k))
else:
print(solve(b - 1, b - a, k))
main()
``` | output | 1 | 43,366 | 8 | 86,733 |
Provide tags and a correct Python 3 solution for this coding contest problem.
Imagine that you are in a building that has exactly n floors. You can move between the floors in a lift. Let's number the floors from bottom to top with integers from 1 to n. Now you're on the floor number a. You are very bored, so you want to take the lift. Floor number b has a secret lab, the entry is forbidden. However, you already are in the mood and decide to make k consecutive trips in the lift.
Let us suppose that at the moment you are on the floor number x (initially, you were on floor a). For another trip between floors you choose some floor with number y (y ≠ x) and the lift travels to this floor. As you cannot visit floor b with the secret lab, you decided that the distance from the current floor x to the chosen y must be strictly less than the distance from the current floor x to floor b with the secret lab. Formally, it means that the following inequation must fulfill: |x - y| < |x - b|. After the lift successfully transports you to floor y, you write down number y in your notepad.
Your task is to find the number of distinct number sequences that you could have written in the notebook as the result of k trips in the lift. As the sought number of trips can be rather large, find the remainder after dividing the number by 1000000007 (109 + 7).
Input
The first line of the input contains four space-separated integers n, a, b, k (2 ≤ n ≤ 5000, 1 ≤ k ≤ 5000, 1 ≤ a, b ≤ n, a ≠ b).
Output
Print a single integer — the remainder after dividing the sought number of sequences by 1000000007 (109 + 7).
Examples
Input
5 2 4 1
Output
2
Input
5 2 4 2
Output
2
Input
5 3 4 1
Output
0
Note
Two sequences p1, p2, ..., pk and q1, q2, ..., qk are distinct, if there is such integer j (1 ≤ j ≤ k), that pj ≠ qj.
Notes to the samples:
1. In the first sample after the first trip you are either on floor 1, or on floor 3, because |1 - 2| < |2 - 4| and |3 - 2| < |2 - 4|.
2. In the second sample there are two possible sequences: (1, 2); (1, 3). You cannot choose floor 3 for the first trip because in this case no floor can be the floor for the second trip.
3. In the third sample there are no sought sequences, because you cannot choose the floor for the first trip. | instruction | 0 | 43,367 | 8 | 86,734 |
Tags: combinatorics, dp
Correct Solution:
```
def solve(n, st, k):
MOD = int(1e9 + 7)
dp = [0] * (n + 1)
prefix_sum = [0] * (n + 1)
dp[st] = 1
for times in range(k):
prefix_sum[0] = 0
for i in range(1, n + 1):
prefix_sum[i] = prefix_sum[i - 1] + dp[i]
if prefix_sum[i] >= MOD: prefix_sum[i] -= MOD
for i in range(1, n + 1):
dp[i] = prefix_sum[n] - dp[i] - prefix_sum[i >> 1]
while dp[i] < 0: dp[i] += MOD
while dp[i] >= MOD: dp[i] -= MOD
return sum(dp) % MOD
def main():
n, a, b, k = [int(i) for i in input().split()]
if a > b:
print(solve(n - b, a - b, k))
else:
print(solve(b - 1, b - a, k))
main()
``` | output | 1 | 43,367 | 8 | 86,735 |
Provide tags and a correct Python 2 solution for this coding contest problem.
Imagine that you are in a building that has exactly n floors. You can move between the floors in a lift. Let's number the floors from bottom to top with integers from 1 to n. Now you're on the floor number a. You are very bored, so you want to take the lift. Floor number b has a secret lab, the entry is forbidden. However, you already are in the mood and decide to make k consecutive trips in the lift.
Let us suppose that at the moment you are on the floor number x (initially, you were on floor a). For another trip between floors you choose some floor with number y (y ≠ x) and the lift travels to this floor. As you cannot visit floor b with the secret lab, you decided that the distance from the current floor x to the chosen y must be strictly less than the distance from the current floor x to floor b with the secret lab. Formally, it means that the following inequation must fulfill: |x - y| < |x - b|. After the lift successfully transports you to floor y, you write down number y in your notepad.
Your task is to find the number of distinct number sequences that you could have written in the notebook as the result of k trips in the lift. As the sought number of trips can be rather large, find the remainder after dividing the number by 1000000007 (109 + 7).
Input
The first line of the input contains four space-separated integers n, a, b, k (2 ≤ n ≤ 5000, 1 ≤ k ≤ 5000, 1 ≤ a, b ≤ n, a ≠ b).
Output
Print a single integer — the remainder after dividing the sought number of sequences by 1000000007 (109 + 7).
Examples
Input
5 2 4 1
Output
2
Input
5 2 4 2
Output
2
Input
5 3 4 1
Output
0
Note
Two sequences p1, p2, ..., pk and q1, q2, ..., qk are distinct, if there is such integer j (1 ≤ j ≤ k), that pj ≠ qj.
Notes to the samples:
1. In the first sample after the first trip you are either on floor 1, or on floor 3, because |1 - 2| < |2 - 4| and |3 - 2| < |2 - 4|.
2. In the second sample there are two possible sequences: (1, 2); (1, 3). You cannot choose floor 3 for the first trip because in this case no floor can be the floor for the second trip.
3. In the third sample there are no sought sequences, because you cannot choose the floor for the first trip. | instruction | 0 | 43,368 | 8 | 86,736 |
Tags: combinatorics, dp
Correct Solution:
```
from sys import stdin, stdout
from collections import Counter, defaultdict
from itertools import permutations, combinations
raw_input = stdin.readline
pr = stdout.write
def in_num():
return int(raw_input())
def in_arr():
return map(int,raw_input().split())
def pr_num(n):
stdout.write(str(n)+'\n')
def pr_arr(arr):
pr(' '.join(map(str,arr))+'\n')
# fast read function for total integer input
def inp():
# this function returns whole input of
# space/line seperated integers
# Use Ctrl+D to flush stdin.
return map(int,stdin.read().split())
range = xrange # not for python 3.0+
mod=10**9+7
n,a,b,k=in_arr()
dp=[[0 for i in range(n+1)] for j in range(k+1)]
dp[0][a-1]=1
dp[0][a]=(-1)%mod
b-=1
for i in range(k):
temp=0
for j in range(n+1):
temp=(temp+dp[i][j])%mod
if i and int(abs(b-j))>1:
temp-=dp[i-1][j]
temp%=mod
dp[i][j]=temp
if j<n:
x=int(abs(b-j))
x-=1
if x<=0:
continue
dp[i+1][max(0,j-x)]=(dp[i+1][max(0,j-x)]+temp)%mod
dp[i+1][min(n,j+x+1)]=(dp[i+1][min(n,j+x+1)]-temp)%mod
#dp[i+1][j]=(dp[i+1][j]-1)%mod
#dp[i+1][j+1]=(dp[i+1][j+1]+1)%mod
if i and int(abs(b-j))>1:
temp+=dp[i-1][j]
temp%=mod
ans=0
temp=0
for i in range(n):
temp+=dp[k][i]
temp%=mod
if int(abs(i-b))>1:
temp-=dp[k-1][i]
temp%=mod
ans+=temp
ans%=mod
if int(abs(i-b))>1:
temp+=dp[k-1][i]
temp%=mod
pr_num(ans)
``` | output | 1 | 43,368 | 8 | 86,737 |
Provide tags and a correct Python 2 solution for this coding contest problem.
Imagine that you are in a building that has exactly n floors. You can move between the floors in a lift. Let's number the floors from bottom to top with integers from 1 to n. Now you're on the floor number a. You are very bored, so you want to take the lift. Floor number b has a secret lab, the entry is forbidden. However, you already are in the mood and decide to make k consecutive trips in the lift.
Let us suppose that at the moment you are on the floor number x (initially, you were on floor a). For another trip between floors you choose some floor with number y (y ≠ x) and the lift travels to this floor. As you cannot visit floor b with the secret lab, you decided that the distance from the current floor x to the chosen y must be strictly less than the distance from the current floor x to floor b with the secret lab. Formally, it means that the following inequation must fulfill: |x - y| < |x - b|. After the lift successfully transports you to floor y, you write down number y in your notepad.
Your task is to find the number of distinct number sequences that you could have written in the notebook as the result of k trips in the lift. As the sought number of trips can be rather large, find the remainder after dividing the number by 1000000007 (109 + 7).
Input
The first line of the input contains four space-separated integers n, a, b, k (2 ≤ n ≤ 5000, 1 ≤ k ≤ 5000, 1 ≤ a, b ≤ n, a ≠ b).
Output
Print a single integer — the remainder after dividing the sought number of sequences by 1000000007 (109 + 7).
Examples
Input
5 2 4 1
Output
2
Input
5 2 4 2
Output
2
Input
5 3 4 1
Output
0
Note
Two sequences p1, p2, ..., pk and q1, q2, ..., qk are distinct, if there is such integer j (1 ≤ j ≤ k), that pj ≠ qj.
Notes to the samples:
1. In the first sample after the first trip you are either on floor 1, or on floor 3, because |1 - 2| < |2 - 4| and |3 - 2| < |2 - 4|.
2. In the second sample there are two possible sequences: (1, 2); (1, 3). You cannot choose floor 3 for the first trip because in this case no floor can be the floor for the second trip.
3. In the third sample there are no sought sequences, because you cannot choose the floor for the first trip. | instruction | 0 | 43,369 | 8 | 86,738 |
Tags: combinatorics, dp
Correct Solution:
```
from sys import stdin, stdout
from collections import Counter, defaultdict
from itertools import permutations, combinations
raw_input = stdin.readline
pr = stdout.write
def in_num():
return int(raw_input())
def in_arr():
return map(int,raw_input().split())
def pr_num(n):
stdout.write(str(n)+'\n')
def pr_arr(arr):
pr(' '.join(map(str,arr))+'\n')
# fast read function for total integer input
def inp():
# this function returns whole input of
# space/line seperated integers
# Use Ctrl+D to flush stdin.
return map(int,stdin.read().split())
range = xrange # not for python 3.0+
mod=10**9+7
n,a,b,k=in_arr()
dp=[[0 for i in range(n+1)] for j in range(k+1)]
dp[0][a-1]=1
dp[0][a]=(-1)%mod
b-=1
for i in range(k):
temp=0
for j in range(n):
temp=(temp+dp[i][j])%mod
x=int(abs(b-j))
x-=1
if x<=0:
continue
dp[i+1][max(0,j-x)]=(dp[i+1][max(0,j-x)]+temp)%mod
dp[i+1][min(n,j+x+1)]=(dp[i+1][min(n,j+x+1)]-temp)%mod
dp[i+1][j]=(dp[i+1][j]-temp)%mod
dp[i+1][j+1]=(dp[i+1][j+1]+temp)%mod
ans=0
temp=0
for i in range(n):
temp+=dp[k][i]
temp%=mod
ans+=temp
ans%=mod
pr_num(ans)
``` | output | 1 | 43,369 | 8 | 86,739 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
Imagine that you are in a building that has exactly n floors. You can move between the floors in a lift. Let's number the floors from bottom to top with integers from 1 to n. Now you're on the floor number a. You are very bored, so you want to take the lift. Floor number b has a secret lab, the entry is forbidden. However, you already are in the mood and decide to make k consecutive trips in the lift.
Let us suppose that at the moment you are on the floor number x (initially, you were on floor a). For another trip between floors you choose some floor with number y (y ≠ x) and the lift travels to this floor. As you cannot visit floor b with the secret lab, you decided that the distance from the current floor x to the chosen y must be strictly less than the distance from the current floor x to floor b with the secret lab. Formally, it means that the following inequation must fulfill: |x - y| < |x - b|. After the lift successfully transports you to floor y, you write down number y in your notepad.
Your task is to find the number of distinct number sequences that you could have written in the notebook as the result of k trips in the lift. As the sought number of trips can be rather large, find the remainder after dividing the number by 1000000007 (109 + 7).
Input
The first line of the input contains four space-separated integers n, a, b, k (2 ≤ n ≤ 5000, 1 ≤ k ≤ 5000, 1 ≤ a, b ≤ n, a ≠ b).
Output
Print a single integer — the remainder after dividing the sought number of sequences by 1000000007 (109 + 7).
Examples
Input
5 2 4 1
Output
2
Input
5 2 4 2
Output
2
Input
5 3 4 1
Output
0
Note
Two sequences p1, p2, ..., pk and q1, q2, ..., qk are distinct, if there is such integer j (1 ≤ j ≤ k), that pj ≠ qj.
Notes to the samples:
1. In the first sample after the first trip you are either on floor 1, or on floor 3, because |1 - 2| < |2 - 4| and |3 - 2| < |2 - 4|.
2. In the second sample there are two possible sequences: (1, 2); (1, 3). You cannot choose floor 3 for the first trip because in this case no floor can be the floor for the second trip.
3. In the third sample there are no sought sequences, because you cannot choose the floor for the first trip.
Submitted Solution:
```
#!/usr/bin/env python3
import io
import os
import sys
input = io.BytesIO(os.read(0,os.fstat(0).st_size)).readline
def printd(*args, **kwargs):
#print(*args, **kwargs, file=sys.stderr)
#print(*args, **kwargs)
pass
def get_str():
return input().decode().strip()
def rint():
return map(int, input().split())
def oint():
return int(input())
mod = 1000000007
n, a, b, k = rint()
if a > b:
a, b = n-a+1, n-b+1
a -= 1
b -= 1
printd(n, a, b, k)
d = [0]*n
d[a] = 1
ps = [0]*b
ps[0] = d[0]
for j in range(1, b):
ps[j] = ps[j-1]+d[j]
while ps[j] > mod:
ps[j] -= mod
printd(n, a, b, k)
printd(d, ps)
for i in range(k):
for j in range(b):
#b-t > t-j
#2*t < b+j
#t < (b+j)/2
if (b+j)%2:
t = (b+j)//2
else:
t = (b+j)//2 - 1
if j == 0:
d[j] = ps[t] - ps[j]
else:
d[j] = ps[t] - ps[j] + ps[j-1]
while d[j] > mod:
d[j] -= mod
while d[j] <0:
d[j] += mod
#d[j] %=mod
ps[0] = d[0]
for j in range(1, b):
ps[j] = (ps[j-1]+d[j])# %mod
while ps[j] > mod:
ps[j] -= mod
while ps[j] < 0:
ps[j] += mod
printd(d,ps)
ans = ps[b-1]
print(ans%mod)
``` | instruction | 0 | 43,370 | 8 | 86,740 |
Yes | output | 1 | 43,370 | 8 | 86,741 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
Imagine that you are in a building that has exactly n floors. You can move between the floors in a lift. Let's number the floors from bottom to top with integers from 1 to n. Now you're on the floor number a. You are very bored, so you want to take the lift. Floor number b has a secret lab, the entry is forbidden. However, you already are in the mood and decide to make k consecutive trips in the lift.
Let us suppose that at the moment you are on the floor number x (initially, you were on floor a). For another trip between floors you choose some floor with number y (y ≠ x) and the lift travels to this floor. As you cannot visit floor b with the secret lab, you decided that the distance from the current floor x to the chosen y must be strictly less than the distance from the current floor x to floor b with the secret lab. Formally, it means that the following inequation must fulfill: |x - y| < |x - b|. After the lift successfully transports you to floor y, you write down number y in your notepad.
Your task is to find the number of distinct number sequences that you could have written in the notebook as the result of k trips in the lift. As the sought number of trips can be rather large, find the remainder after dividing the number by 1000000007 (109 + 7).
Input
The first line of the input contains four space-separated integers n, a, b, k (2 ≤ n ≤ 5000, 1 ≤ k ≤ 5000, 1 ≤ a, b ≤ n, a ≠ b).
Output
Print a single integer — the remainder after dividing the sought number of sequences by 1000000007 (109 + 7).
Examples
Input
5 2 4 1
Output
2
Input
5 2 4 2
Output
2
Input
5 3 4 1
Output
0
Note
Two sequences p1, p2, ..., pk and q1, q2, ..., qk are distinct, if there is such integer j (1 ≤ j ≤ k), that pj ≠ qj.
Notes to the samples:
1. In the first sample after the first trip you are either on floor 1, or on floor 3, because |1 - 2| < |2 - 4| and |3 - 2| < |2 - 4|.
2. In the second sample there are two possible sequences: (1, 2); (1, 3). You cannot choose floor 3 for the first trip because in this case no floor can be the floor for the second trip.
3. In the third sample there are no sought sequences, because you cannot choose the floor for the first trip.
Submitted Solution:
```
#!/usr/bin/env python3
from sys import stdin
MOD = int(1e9)+7
def solve(tc):
n, a, b, k = map(int, stdin.readline().split())
dp = [1 for i in range(n+1)]
dp[b] = 0
prefix = [1 for i in range(n+1)]
for i in range(k):
for j in range(1, n+1):
prefix[j] = prefix[j-1] + dp[j]
prefix[j] %= MOD
for j in range(1, b-1):
dist = b - j
start = max(0, j-dist)
end = min(b-1, j+dist-1)
dp[j] = prefix[j-1] - prefix[start]
if dp[j] < 0:
dp[j] += MOD
dp[j] %= MOD
dp[j] += prefix[end] - prefix[j]
if dp[j] < 0:
dp[j] += MOD
dp[j] %= MOD
dp[b-1] = dp[b] = 0
if b+1 <= n:
dp[b+1] = 0
for j in range(b+2, n+1):
dist = j - b
start = max(b, j-dist)
end = min(n, j+dist-1)
dp[j] = prefix[j-1] - prefix[start]
if dp[j] < 0:
dp[j] += MOD
dp[j] %= MOD
dp[j] += prefix[end] - prefix[j]
if dp[j] < 0:
dp[j] += MOD
dp[j] %= MOD
print(dp[a])
tc = 1
solve(tc)
``` | instruction | 0 | 43,371 | 8 | 86,742 |
Yes | output | 1 | 43,371 | 8 | 86,743 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
Imagine that you are in a building that has exactly n floors. You can move between the floors in a lift. Let's number the floors from bottom to top with integers from 1 to n. Now you're on the floor number a. You are very bored, so you want to take the lift. Floor number b has a secret lab, the entry is forbidden. However, you already are in the mood and decide to make k consecutive trips in the lift.
Let us suppose that at the moment you are on the floor number x (initially, you were on floor a). For another trip between floors you choose some floor with number y (y ≠ x) and the lift travels to this floor. As you cannot visit floor b with the secret lab, you decided that the distance from the current floor x to the chosen y must be strictly less than the distance from the current floor x to floor b with the secret lab. Formally, it means that the following inequation must fulfill: |x - y| < |x - b|. After the lift successfully transports you to floor y, you write down number y in your notepad.
Your task is to find the number of distinct number sequences that you could have written in the notebook as the result of k trips in the lift. As the sought number of trips can be rather large, find the remainder after dividing the number by 1000000007 (109 + 7).
Input
The first line of the input contains four space-separated integers n, a, b, k (2 ≤ n ≤ 5000, 1 ≤ k ≤ 5000, 1 ≤ a, b ≤ n, a ≠ b).
Output
Print a single integer — the remainder after dividing the sought number of sequences by 1000000007 (109 + 7).
Examples
Input
5 2 4 1
Output
2
Input
5 2 4 2
Output
2
Input
5 3 4 1
Output
0
Note
Two sequences p1, p2, ..., pk and q1, q2, ..., qk are distinct, if there is such integer j (1 ≤ j ≤ k), that pj ≠ qj.
Notes to the samples:
1. In the first sample after the first trip you are either on floor 1, or on floor 3, because |1 - 2| < |2 - 4| and |3 - 2| < |2 - 4|.
2. In the second sample there are two possible sequences: (1, 2); (1, 3). You cannot choose floor 3 for the first trip because in this case no floor can be the floor for the second trip.
3. In the third sample there are no sought sequences, because you cannot choose the floor for the first trip.
Submitted Solution:
```
#!/usr/bin/env python3
import io
import os
import sys
input = io.BytesIO(os.read(0,os.fstat(0).st_size)).readline
def printd(*args, **kwargs):
#print(*args, **kwargs, file=sys.stderr)
#print(*args, **kwargs)
pass
def get_str():
return input().decode().strip()
def rint():
return map(int, input().split())
def oint():
return int(input())
mod = 1000000007
n, a, b, k = rint()
if a > b:
a, b = n-a+1, n-b+1
a -= 1
b -= 1
printd(n, a, b, k)
d = [0]*n
d[a] = 1
ps = [0]*b
ps[0] = d[0]
for j in range(1, b):
ps[j] = ps[j-1]+d[j]
ps[j] %= mod
printd(n, a, b, k)
printd(d, ps)
for i in range(k):
for j in range(b):
#b-t > t-j
#2*t < b+j
#t < (b+j)/2
if (b+j)%2:
t = (b+j)//2
else:
t = (b+j)//2 - 1
if j == 0:
d[j] = ps[t] - ps[j]
else:
d[j] = ps[t] - ps[j] + ps[j-1]
d[j] %= mod
#d[j] %=mod
ps[0] = d[0]
for j in range(1, b):
ps[j] = (ps[j-1]+d[j])# %mod
ps[j] %= mod
printd(d,ps)
ans = ps[b-1]
print(ans%mod)
``` | instruction | 0 | 43,372 | 8 | 86,744 |
Yes | output | 1 | 43,372 | 8 | 86,745 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
Imagine that you are in a building that has exactly n floors. You can move between the floors in a lift. Let's number the floors from bottom to top with integers from 1 to n. Now you're on the floor number a. You are very bored, so you want to take the lift. Floor number b has a secret lab, the entry is forbidden. However, you already are in the mood and decide to make k consecutive trips in the lift.
Let us suppose that at the moment you are on the floor number x (initially, you were on floor a). For another trip between floors you choose some floor with number y (y ≠ x) and the lift travels to this floor. As you cannot visit floor b with the secret lab, you decided that the distance from the current floor x to the chosen y must be strictly less than the distance from the current floor x to floor b with the secret lab. Formally, it means that the following inequation must fulfill: |x - y| < |x - b|. After the lift successfully transports you to floor y, you write down number y in your notepad.
Your task is to find the number of distinct number sequences that you could have written in the notebook as the result of k trips in the lift. As the sought number of trips can be rather large, find the remainder after dividing the number by 1000000007 (109 + 7).
Input
The first line of the input contains four space-separated integers n, a, b, k (2 ≤ n ≤ 5000, 1 ≤ k ≤ 5000, 1 ≤ a, b ≤ n, a ≠ b).
Output
Print a single integer — the remainder after dividing the sought number of sequences by 1000000007 (109 + 7).
Examples
Input
5 2 4 1
Output
2
Input
5 2 4 2
Output
2
Input
5 3 4 1
Output
0
Note
Two sequences p1, p2, ..., pk and q1, q2, ..., qk are distinct, if there is such integer j (1 ≤ j ≤ k), that pj ≠ qj.
Notes to the samples:
1. In the first sample after the first trip you are either on floor 1, or on floor 3, because |1 - 2| < |2 - 4| and |3 - 2| < |2 - 4|.
2. In the second sample there are two possible sequences: (1, 2); (1, 3). You cannot choose floor 3 for the first trip because in this case no floor can be the floor for the second trip.
3. In the third sample there are no sought sequences, because you cannot choose the floor for the first trip.
Submitted Solution:
```
def solve(n, st, k):
MOD = int(1e9 + 7)
dp = [0] * (n + 1)
prefix_sum = [0] * (n + 1)
dp[st] = 1
for times in range(k):
prefix_sum[0] = 0
for i in range(1, n + 1):
prefix_sum[i] = prefix_sum[i - 1] + dp[i]
if prefix_sum[i] >= MOD: prefix_sum[i] -= MOD
for i in range(1, n + 1):
dp[i] = prefix_sum[n] - prefix_sum[i] + prefix_sum[i - 1] - prefix_sum[i >> 1]
while dp[i] < 0: dp[i] += MOD
while dp[i] >= MOD: dp[i] -= MOD
return sum(dp) % MOD
def main():
n, a, b, k = [int(i) for i in input().split()]
if a > b:
print(solve(n - b, a - b, k))
else:
print(solve(b - 1, b - a, k))
main()
``` | instruction | 0 | 43,373 | 8 | 86,746 |
Yes | output | 1 | 43,373 | 8 | 86,747 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
Imagine that you are in a building that has exactly n floors. You can move between the floors in a lift. Let's number the floors from bottom to top with integers from 1 to n. Now you're on the floor number a. You are very bored, so you want to take the lift. Floor number b has a secret lab, the entry is forbidden. However, you already are in the mood and decide to make k consecutive trips in the lift.
Let us suppose that at the moment you are on the floor number x (initially, you were on floor a). For another trip between floors you choose some floor with number y (y ≠ x) and the lift travels to this floor. As you cannot visit floor b with the secret lab, you decided that the distance from the current floor x to the chosen y must be strictly less than the distance from the current floor x to floor b with the secret lab. Formally, it means that the following inequation must fulfill: |x - y| < |x - b|. After the lift successfully transports you to floor y, you write down number y in your notepad.
Your task is to find the number of distinct number sequences that you could have written in the notebook as the result of k trips in the lift. As the sought number of trips can be rather large, find the remainder after dividing the number by 1000000007 (109 + 7).
Input
The first line of the input contains four space-separated integers n, a, b, k (2 ≤ n ≤ 5000, 1 ≤ k ≤ 5000, 1 ≤ a, b ≤ n, a ≠ b).
Output
Print a single integer — the remainder after dividing the sought number of sequences by 1000000007 (109 + 7).
Examples
Input
5 2 4 1
Output
2
Input
5 2 4 2
Output
2
Input
5 3 4 1
Output
0
Note
Two sequences p1, p2, ..., pk and q1, q2, ..., qk are distinct, if there is such integer j (1 ≤ j ≤ k), that pj ≠ qj.
Notes to the samples:
1. In the first sample after the first trip you are either on floor 1, or on floor 3, because |1 - 2| < |2 - 4| and |3 - 2| < |2 - 4|.
2. In the second sample there are two possible sequences: (1, 2); (1, 3). You cannot choose floor 3 for the first trip because in this case no floor can be the floor for the second trip.
3. In the third sample there are no sought sequences, because you cannot choose the floor for the first trip.
Submitted Solution:
```
modulo = 1000000007
n, a, b, k = map(int, input().split())
a = a-1
b = b-1
ceros = [0]*n
ceros[a] = 1
for i in range(1, k+1):
ceros2 = [0]*n
for j in range(n):
cj = ceros[j]
longitud = abs(j-b)-1
l = max(0,j-longitud)
r = min(n-1,j+longitud)
if l < r:
ceros2[l] += cj
if ceros2[l] > modulo:
ceros2[l] -= modulo
ceros2[j] -= cj
if j+1 < n:
ceros2[j+1] += cj
if ceros2[j+1] > modulo:
ceros2[j+1] -= modulo
if r+1 < n:
ceros2[r+1] -= cj
for j in range(1,n):
ceros[j] = (ceros2[j]+ceros2[j-1]) % modulo
ceros[0] = ceros2[0]
ans = 0
for i in ceros2:
ans = (ans + i) % modulo
print(ans)
``` | instruction | 0 | 43,374 | 8 | 86,748 |
No | output | 1 | 43,374 | 8 | 86,749 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
Imagine that you are in a building that has exactly n floors. You can move between the floors in a lift. Let's number the floors from bottom to top with integers from 1 to n. Now you're on the floor number a. You are very bored, so you want to take the lift. Floor number b has a secret lab, the entry is forbidden. However, you already are in the mood and decide to make k consecutive trips in the lift.
Let us suppose that at the moment you are on the floor number x (initially, you were on floor a). For another trip between floors you choose some floor with number y (y ≠ x) and the lift travels to this floor. As you cannot visit floor b with the secret lab, you decided that the distance from the current floor x to the chosen y must be strictly less than the distance from the current floor x to floor b with the secret lab. Formally, it means that the following inequation must fulfill: |x - y| < |x - b|. After the lift successfully transports you to floor y, you write down number y in your notepad.
Your task is to find the number of distinct number sequences that you could have written in the notebook as the result of k trips in the lift. As the sought number of trips can be rather large, find the remainder after dividing the number by 1000000007 (109 + 7).
Input
The first line of the input contains four space-separated integers n, a, b, k (2 ≤ n ≤ 5000, 1 ≤ k ≤ 5000, 1 ≤ a, b ≤ n, a ≠ b).
Output
Print a single integer — the remainder after dividing the sought number of sequences by 1000000007 (109 + 7).
Examples
Input
5 2 4 1
Output
2
Input
5 2 4 2
Output
2
Input
5 3 4 1
Output
0
Note
Two sequences p1, p2, ..., pk and q1, q2, ..., qk are distinct, if there is such integer j (1 ≤ j ≤ k), that pj ≠ qj.
Notes to the samples:
1. In the first sample after the first trip you are either on floor 1, or on floor 3, because |1 - 2| < |2 - 4| and |3 - 2| < |2 - 4|.
2. In the second sample there are two possible sequences: (1, 2); (1, 3). You cannot choose floor 3 for the first trip because in this case no floor can be the floor for the second trip.
3. In the third sample there are no sought sequences, because you cannot choose the floor for the first trip.
Submitted Solution:
```
n, a, b, k = [int(n) for n in input().split()]
a = a - 1
b = b - 1
A = [2 * max(b-i-1, 0) for i in range(n)]
R = A
#for i in range(n):
# print(A[i])
#print('--')
for i in range(1,k):
for j in range(n):
for l in range(1, abs(b - j)):
if A[j + l]:
R[j] = A[j]*A[j+l] % 1000000007
#for i in range(n):
# print(R[i])
#print('--')
print(R[a])
``` | instruction | 0 | 43,375 | 8 | 86,750 |
No | output | 1 | 43,375 | 8 | 86,751 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
Imagine that you are in a building that has exactly n floors. You can move between the floors in a lift. Let's number the floors from bottom to top with integers from 1 to n. Now you're on the floor number a. You are very bored, so you want to take the lift. Floor number b has a secret lab, the entry is forbidden. However, you already are in the mood and decide to make k consecutive trips in the lift.
Let us suppose that at the moment you are on the floor number x (initially, you were on floor a). For another trip between floors you choose some floor with number y (y ≠ x) and the lift travels to this floor. As you cannot visit floor b with the secret lab, you decided that the distance from the current floor x to the chosen y must be strictly less than the distance from the current floor x to floor b with the secret lab. Formally, it means that the following inequation must fulfill: |x - y| < |x - b|. After the lift successfully transports you to floor y, you write down number y in your notepad.
Your task is to find the number of distinct number sequences that you could have written in the notebook as the result of k trips in the lift. As the sought number of trips can be rather large, find the remainder after dividing the number by 1000000007 (109 + 7).
Input
The first line of the input contains four space-separated integers n, a, b, k (2 ≤ n ≤ 5000, 1 ≤ k ≤ 5000, 1 ≤ a, b ≤ n, a ≠ b).
Output
Print a single integer — the remainder after dividing the sought number of sequences by 1000000007 (109 + 7).
Examples
Input
5 2 4 1
Output
2
Input
5 2 4 2
Output
2
Input
5 3 4 1
Output
0
Note
Two sequences p1, p2, ..., pk and q1, q2, ..., qk are distinct, if there is such integer j (1 ≤ j ≤ k), that pj ≠ qj.
Notes to the samples:
1. In the first sample after the first trip you are either on floor 1, or on floor 3, because |1 - 2| < |2 - 4| and |3 - 2| < |2 - 4|.
2. In the second sample there are two possible sequences: (1, 2); (1, 3). You cannot choose floor 3 for the first trip because in this case no floor can be the floor for the second trip.
3. In the third sample there are no sought sequences, because you cannot choose the floor for the first trip.
Submitted Solution:
```
#!/usr/bin/env python3
import io
import os
import sys
input = io.BytesIO(os.read(0,os.fstat(0).st_size)).readline
def printd(*args, **kwargs):
#print(*args, **kwargs, file=sys.stderr)
#print(*args, **kwargs)
pass
def get_str():
return input().decode().strip()
def rint():
return map(int, input().split())
def oint():
return int(input())
mod = 1000000007
n, a, b, k = rint()
a -= 1
b -= 1
d = [0]*n
d[a] = 1
ps = [0]*n
ps[0] = d[0]
for j in range(1, n):
ps[j] = ps[j-1]+d[j]
printd(n, a, b, k)
printd(d, ps)
for i in range(k):
d = [0]*n
for j in range(1, b):
d[j] = ps[j-1]
for j in range(b):
#b-t > t-j
#2*t < b+j
#t < (b+j)/2
if (b+j)%2:
t = (b+j)//2
else:
t = (b+j)//2 - 1
d[j] += ps[t] - ps[j]
ps = [0]*n
ps[0] = d[0]
for j in range(1, n):
ps[j] = (ps[j-1]+d[j])%mod
printd(d,ps)
print(ps[n-1]%mod)
``` | instruction | 0 | 43,376 | 8 | 86,752 |
No | output | 1 | 43,376 | 8 | 86,753 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
Imagine that you are in a building that has exactly n floors. You can move between the floors in a lift. Let's number the floors from bottom to top with integers from 1 to n. Now you're on the floor number a. You are very bored, so you want to take the lift. Floor number b has a secret lab, the entry is forbidden. However, you already are in the mood and decide to make k consecutive trips in the lift.
Let us suppose that at the moment you are on the floor number x (initially, you were on floor a). For another trip between floors you choose some floor with number y (y ≠ x) and the lift travels to this floor. As you cannot visit floor b with the secret lab, you decided that the distance from the current floor x to the chosen y must be strictly less than the distance from the current floor x to floor b with the secret lab. Formally, it means that the following inequation must fulfill: |x - y| < |x - b|. After the lift successfully transports you to floor y, you write down number y in your notepad.
Your task is to find the number of distinct number sequences that you could have written in the notebook as the result of k trips in the lift. As the sought number of trips can be rather large, find the remainder after dividing the number by 1000000007 (109 + 7).
Input
The first line of the input contains four space-separated integers n, a, b, k (2 ≤ n ≤ 5000, 1 ≤ k ≤ 5000, 1 ≤ a, b ≤ n, a ≠ b).
Output
Print a single integer — the remainder after dividing the sought number of sequences by 1000000007 (109 + 7).
Examples
Input
5 2 4 1
Output
2
Input
5 2 4 2
Output
2
Input
5 3 4 1
Output
0
Note
Two sequences p1, p2, ..., pk and q1, q2, ..., qk are distinct, if there is such integer j (1 ≤ j ≤ k), that pj ≠ qj.
Notes to the samples:
1. In the first sample after the first trip you are either on floor 1, or on floor 3, because |1 - 2| < |2 - 4| and |3 - 2| < |2 - 4|.
2. In the second sample there are two possible sequences: (1, 2); (1, 3). You cannot choose floor 3 for the first trip because in this case no floor can be the floor for the second trip.
3. In the third sample there are no sought sequences, because you cannot choose the floor for the first trip.
Submitted Solution:
```
modulo = 1000000007
n, a, b, k = map(int, input().split())
a = a-1
b = b-1
if a < b:
n = b+1
else :
a = a-b
n = n-b
b = 0
ceros = [0]*n
ceros[a] = 1
for i in range(1, k+1):
ceros2 = [0]*n
for j in range(n):
cj = ceros[j]
longitud = abs(j-b)-1
l = max(0,j-longitud)
r = min(n-1,j+longitud)
if l < r:
ceros2[l] = (cj + ceros2[l]) % modulo
ceros2[j] -= cj
if j+1 < n:
ceros2[j+1] += (cj+ceros2[j+1]) % modulo
if r+1 < n:
ceros2[r+1] -= cj
for j in range(1,n):
ceros2[j] = (ceros2[j]+ceros2[j-1]) % modulo
ceros = ceros2
print(sum(ceros2)%modulo)
``` | instruction | 0 | 43,377 | 8 | 86,754 |
No | output | 1 | 43,377 | 8 | 86,755 |
Provide a correct Python 3 solution for this coding contest problem.
problem
A mysterious $ X $ [cm] plant grows in one place. This plant has the following mysterious properties.
* Say "nobiro" to this plant and it will grow $ A $ [cm].
* Say "tidime" to this plant and it will grow $ B $ [cm].
* If you say "karero" to this plant, it will be $ 0 $ [cm].
However, this plant does not have a negative length. Specifically, when it grows from the state of $ C $ [cm] to $ D $ [cm] $ (C + D \ lt 0) $, it is a plant. Stops growing when it reaches $ 0 $ [cm].
Say one of "nobiro", "tidime", "karero" to this plant only once a day for $ N $ days. Find the length [cm] of the plant after $ N $ days.
output
Print the length of the plant after $ N $ days. Also print a newline at the end.
Example
Input
10 30 10
3
nobiro
nobiro
tidime
Output
80 | instruction | 0 | 43,782 | 8 | 87,564 |
"Correct Solution:
```
#!/usr/bin/env python3
from collections import defaultdict,deque
from heapq import heappush, heappop
from bisect import *
import sys, random, itertools, math
sys.setrecursionlimit(10**5)
input = sys.stdin.readline
sqrt = math.sqrt
def LI(): return list(map(int, input().split()))
def LF(): return list(map(float, input().split()))
def LI_(): return list(map(lambda x: int(x)-1, input().split()))
def II(): return int(input())
def IF(): return float(input())
def LS(): return list(map(list, input().split()))
def S(): return list(input().rstrip())
def IR(n): return [II() for _ in range(n)]
def LIR(n): return [LI() for _ in range(n)]
def FR(n): return [IF() for _ in range(n)]
def LFR(n): return [LI() for _ in range(n)]
def LIR_(n): return [LI_() for _ in range(n)]
def SR(n): return [S() for _ in range(n)]
def LSR(n): return [LS() for _ in range(n)]
mod = 1000000007
inf = float('INF')
#A
def A():
x,a,b = LI()
n = II()
ans = x
for _ in range(n):
s = S()
if s == list("nobiro"):
ans += a
elif s == list("tidime"):
ans += b
else:
ans = 0
ans = max(ans, 0)
print(ans)
return
#B
def B():
return
#C
def C():
return
#D
def D():
return
#E
def E():
return
#F
def F():
return
#G
def G():
return
#H
def H():
return
#Solve
if __name__ == '__main__':
A()
``` | output | 1 | 43,782 | 8 | 87,565 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
Hilbert's Hotel is a very unusual hotel since the number of rooms is infinite! In fact, there is exactly one room for every integer, including zero and negative integers. Even stranger, the hotel is currently at full capacity, meaning there is exactly one guest in every room. The hotel's manager, David Hilbert himself, decides he wants to shuffle the guests around because he thinks this will create a vacancy (a room without a guest).
For any integer k and positive integer n, let kmod n denote the remainder when k is divided by n. More formally, r=kmod n is the smallest non-negative integer such that k-r is divisible by n. It always holds that 0≤ kmod n≤ n-1. For example, 100mod 12=4 and (-1337)mod 3=1.
Then the shuffling works as follows. There is an array of n integers a_0,a_1,…,a_{n-1}. Then for each integer k, the guest in room k is moved to room number k+a_{kmod n}.
After this shuffling process, determine if there is still exactly one guest assigned to each room. That is, there are no vacancies or rooms with multiple guests.
Input
Each test consists of multiple test cases. The first line contains a single integer t (1≤ t≤ 10^4) — the number of test cases. Next 2t lines contain descriptions of test cases.
The first line of each test case contains a single integer n (1≤ n≤ 2⋅ 10^5) — the length of the array.
The second line of each test case contains n integers a_0,a_1,…,a_{n-1} (-10^9≤ a_i≤ 10^9).
It is guaranteed that the sum of n over all test cases does not exceed 2⋅ 10^5.
Output
For each test case, output a single line containing "YES" if there is exactly one guest assigned to each room after the shuffling process, or "NO" otherwise. You can print each letter in any case (upper or lower).
Example
Input
6
1
14
2
1 -1
4
5 5 5 1
3
3 2 1
2
0 1
5
-239 -2 -100 -3 -11
Output
YES
YES
YES
NO
NO
YES
Note
In the first test case, every guest is shifted by 14 rooms, so the assignment is still unique.
In the second test case, even guests move to the right by 1 room, and odd guests move to the left by 1 room. We can show that the assignment is still unique.
In the third test case, every fourth guest moves to the right by 1 room, and the other guests move to the right by 5 rooms. We can show that the assignment is still unique.
In the fourth test case, guests 0 and 1 are both assigned to room 3.
In the fifth test case, guests 1 and 2 are both assigned to room 2.
Submitted Solution:
```
t = int(input())
for _ in range(t):
n = int(input())
a = list(map(int, input().split()))
li = [0]*n
for i in range(n):
li[(i+a[i])%n] += 1
for i in li:
if i!=1:
print('NO')
break
else:
print('YES')
``` | instruction | 0 | 44,002 | 8 | 88,004 |
Yes | output | 1 | 44,002 | 8 | 88,005 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
Hilbert's Hotel is a very unusual hotel since the number of rooms is infinite! In fact, there is exactly one room for every integer, including zero and negative integers. Even stranger, the hotel is currently at full capacity, meaning there is exactly one guest in every room. The hotel's manager, David Hilbert himself, decides he wants to shuffle the guests around because he thinks this will create a vacancy (a room without a guest).
For any integer k and positive integer n, let kmod n denote the remainder when k is divided by n. More formally, r=kmod n is the smallest non-negative integer such that k-r is divisible by n. It always holds that 0≤ kmod n≤ n-1. For example, 100mod 12=4 and (-1337)mod 3=1.
Then the shuffling works as follows. There is an array of n integers a_0,a_1,…,a_{n-1}. Then for each integer k, the guest in room k is moved to room number k+a_{kmod n}.
After this shuffling process, determine if there is still exactly one guest assigned to each room. That is, there are no vacancies or rooms with multiple guests.
Input
Each test consists of multiple test cases. The first line contains a single integer t (1≤ t≤ 10^4) — the number of test cases. Next 2t lines contain descriptions of test cases.
The first line of each test case contains a single integer n (1≤ n≤ 2⋅ 10^5) — the length of the array.
The second line of each test case contains n integers a_0,a_1,…,a_{n-1} (-10^9≤ a_i≤ 10^9).
It is guaranteed that the sum of n over all test cases does not exceed 2⋅ 10^5.
Output
For each test case, output a single line containing "YES" if there is exactly one guest assigned to each room after the shuffling process, or "NO" otherwise. You can print each letter in any case (upper or lower).
Example
Input
6
1
14
2
1 -1
4
5 5 5 1
3
3 2 1
2
0 1
5
-239 -2 -100 -3 -11
Output
YES
YES
YES
NO
NO
YES
Note
In the first test case, every guest is shifted by 14 rooms, so the assignment is still unique.
In the second test case, even guests move to the right by 1 room, and odd guests move to the left by 1 room. We can show that the assignment is still unique.
In the third test case, every fourth guest moves to the right by 1 room, and the other guests move to the right by 5 rooms. We can show that the assignment is still unique.
In the fourth test case, guests 0 and 1 are both assigned to room 3.
In the fifth test case, guests 1 and 2 are both assigned to room 2.
Submitted Solution:
```
import sys
input = sys.stdin.readline
for _ in range(int(input())):
l = int(input())
a = list(map(int,input().split()))
b = []
for i in range(l):
a[i] = a[i] % l
b.append(0)
for i in range(l):
b[(a[i]+i)%l] = 1
s = 1
for c in b:
if c != 1:
s = 0
if s == 1:
print('yes')
else:
print('no')
``` | instruction | 0 | 44,003 | 8 | 88,006 |
Yes | output | 1 | 44,003 | 8 | 88,007 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
Hilbert's Hotel is a very unusual hotel since the number of rooms is infinite! In fact, there is exactly one room for every integer, including zero and negative integers. Even stranger, the hotel is currently at full capacity, meaning there is exactly one guest in every room. The hotel's manager, David Hilbert himself, decides he wants to shuffle the guests around because he thinks this will create a vacancy (a room without a guest).
For any integer k and positive integer n, let kmod n denote the remainder when k is divided by n. More formally, r=kmod n is the smallest non-negative integer such that k-r is divisible by n. It always holds that 0≤ kmod n≤ n-1. For example, 100mod 12=4 and (-1337)mod 3=1.
Then the shuffling works as follows. There is an array of n integers a_0,a_1,…,a_{n-1}. Then for each integer k, the guest in room k is moved to room number k+a_{kmod n}.
After this shuffling process, determine if there is still exactly one guest assigned to each room. That is, there are no vacancies or rooms with multiple guests.
Input
Each test consists of multiple test cases. The first line contains a single integer t (1≤ t≤ 10^4) — the number of test cases. Next 2t lines contain descriptions of test cases.
The first line of each test case contains a single integer n (1≤ n≤ 2⋅ 10^5) — the length of the array.
The second line of each test case contains n integers a_0,a_1,…,a_{n-1} (-10^9≤ a_i≤ 10^9).
It is guaranteed that the sum of n over all test cases does not exceed 2⋅ 10^5.
Output
For each test case, output a single line containing "YES" if there is exactly one guest assigned to each room after the shuffling process, or "NO" otherwise. You can print each letter in any case (upper or lower).
Example
Input
6
1
14
2
1 -1
4
5 5 5 1
3
3 2 1
2
0 1
5
-239 -2 -100 -3 -11
Output
YES
YES
YES
NO
NO
YES
Note
In the first test case, every guest is shifted by 14 rooms, so the assignment is still unique.
In the second test case, even guests move to the right by 1 room, and odd guests move to the left by 1 room. We can show that the assignment is still unique.
In the third test case, every fourth guest moves to the right by 1 room, and the other guests move to the right by 5 rooms. We can show that the assignment is still unique.
In the fourth test case, guests 0 and 1 are both assigned to room 3.
In the fifth test case, guests 1 and 2 are both assigned to room 2.
Submitted Solution:
```
from collections import defaultdict
t = int(input())
for _ in range(t):
n = int(input())
arr = [int(i) for i in input().split()]
Dict = defaultdict(int)
flag = 0
for i in range(n):
Dict[(arr[i] + i) % n] += 1
if Dict[(arr[i] + i) % n] > 1:
flag = 1
if flag == 0:
print("YES")
else:
print("NO")
``` | instruction | 0 | 44,004 | 8 | 88,008 |
Yes | output | 1 | 44,004 | 8 | 88,009 |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.