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.
Dreamoon wants to climb up a stair of n steps. He can climb 1 or 2 steps at each move. Dreamoon wants the number of moves to be a multiple of an integer m.
What is the minimal number of moves making him climb to the top of the stairs that satisfies his condition?
Input
The single line contains two space separated integers n, m (0 < n ≤ 10000, 1 < m ≤ 10).
Output
Print a single integer — the minimal number of moves being a multiple of m. If there is no way he can climb satisfying condition print - 1 instead.
Examples
Input
10 2
Output
6
Input
3 5
Output
-1
Note
For the first sample, Dreamoon could climb in 6 moves with following sequence of steps: {2, 2, 2, 2, 1, 1}.
For the second sample, there are only three valid sequence of steps {2, 1}, {1, 2}, {1, 1, 1} with 2, 2, and 3 steps respectively. All these numbers are not multiples of 5. | instruction | 0 | 81,173 | 8 | 162,346 |
Tags: implementation, math
Correct Solution:
```
import math
n,m = map(int,input().split())
if n<m:
print(-1)
else:
x = math.ceil(n/2)
y = x/m
z = m*math.ceil(y)
print(int(z))
``` | output | 1 | 81,173 | 8 | 162,347 |
Provide tags and a correct Python 3 solution for this coding contest problem.
Dreamoon wants to climb up a stair of n steps. He can climb 1 or 2 steps at each move. Dreamoon wants the number of moves to be a multiple of an integer m.
What is the minimal number of moves making him climb to the top of the stairs that satisfies his condition?
Input
The single line contains two space separated integers n, m (0 < n ≤ 10000, 1 < m ≤ 10).
Output
Print a single integer — the minimal number of moves being a multiple of m. If there is no way he can climb satisfying condition print - 1 instead.
Examples
Input
10 2
Output
6
Input
3 5
Output
-1
Note
For the first sample, Dreamoon could climb in 6 moves with following sequence of steps: {2, 2, 2, 2, 1, 1}.
For the second sample, there are only three valid sequence of steps {2, 1}, {1, 2}, {1, 1, 1} with 2, 2, and 3 steps respectively. All these numbers are not multiples of 5. | instruction | 0 | 81,174 | 8 | 162,348 |
Tags: implementation, math
Correct Solution:
```
n, m = map(int, input().split())
ans = n+1
for i in range(n):
y = n - (i+1)*m
x = (i+1)*m - y
if x*y >= 0 and x >= 0:
ans = min(ans, x+y)
if ans == n+1:
print(-1)
else:
print(ans)
``` | output | 1 | 81,174 | 8 | 162,349 |
Provide tags and a correct Python 3 solution for this coding contest problem.
Dreamoon wants to climb up a stair of n steps. He can climb 1 or 2 steps at each move. Dreamoon wants the number of moves to be a multiple of an integer m.
What is the minimal number of moves making him climb to the top of the stairs that satisfies his condition?
Input
The single line contains two space separated integers n, m (0 < n ≤ 10000, 1 < m ≤ 10).
Output
Print a single integer — the minimal number of moves being a multiple of m. If there is no way he can climb satisfying condition print - 1 instead.
Examples
Input
10 2
Output
6
Input
3 5
Output
-1
Note
For the first sample, Dreamoon could climb in 6 moves with following sequence of steps: {2, 2, 2, 2, 1, 1}.
For the second sample, there are only three valid sequence of steps {2, 1}, {1, 2}, {1, 1, 1} with 2, 2, and 3 steps respectively. All these numbers are not multiples of 5. | instruction | 0 | 81,175 | 8 | 162,350 |
Tags: implementation, math
Correct Solution:
```
steps, goon = input().split(" ")
steps = int(steps)
goon = int(goon)
counter = 0
if (steps >= goon):
while True:
if steps > 1:
steps -= 2
counter += 1
elif steps == 1:
steps -= 1
counter += 1
if steps == 0:
break
while (counter % goon != 0):
counter += 1
print(counter)
else:
print(-1)
``` | output | 1 | 81,175 | 8 | 162,351 |
Provide tags and a correct Python 3 solution for this coding contest problem.
Dreamoon wants to climb up a stair of n steps. He can climb 1 or 2 steps at each move. Dreamoon wants the number of moves to be a multiple of an integer m.
What is the minimal number of moves making him climb to the top of the stairs that satisfies his condition?
Input
The single line contains two space separated integers n, m (0 < n ≤ 10000, 1 < m ≤ 10).
Output
Print a single integer — the minimal number of moves being a multiple of m. If there is no way he can climb satisfying condition print - 1 instead.
Examples
Input
10 2
Output
6
Input
3 5
Output
-1
Note
For the first sample, Dreamoon could climb in 6 moves with following sequence of steps: {2, 2, 2, 2, 1, 1}.
For the second sample, there are only three valid sequence of steps {2, 1}, {1, 2}, {1, 1, 1} with 2, 2, and 3 steps respectively. All these numbers are not multiples of 5. | instruction | 0 | 81,176 | 8 | 162,352 |
Tags: implementation, math
Correct Solution:
```
n,m = map(int, input().split(" "))
res=n+1
for i in range(n):
if (i+n-2*i)%m==0 and n-2*i>=0:
res=min(res,i+n-2*i)
if (res==n+1):
print(-1)
else:
print(res)
``` | output | 1 | 81,176 | 8 | 162,353 |
Provide tags and a correct Python 3 solution for this coding contest problem.
Dreamoon wants to climb up a stair of n steps. He can climb 1 or 2 steps at each move. Dreamoon wants the number of moves to be a multiple of an integer m.
What is the minimal number of moves making him climb to the top of the stairs that satisfies his condition?
Input
The single line contains two space separated integers n, m (0 < n ≤ 10000, 1 < m ≤ 10).
Output
Print a single integer — the minimal number of moves being a multiple of m. If there is no way he can climb satisfying condition print - 1 instead.
Examples
Input
10 2
Output
6
Input
3 5
Output
-1
Note
For the first sample, Dreamoon could climb in 6 moves with following sequence of steps: {2, 2, 2, 2, 1, 1}.
For the second sample, there are only three valid sequence of steps {2, 1}, {1, 2}, {1, 1, 1} with 2, 2, and 3 steps respectively. All these numbers are not multiples of 5. | instruction | 0 | 81,177 | 8 | 162,354 |
Tags: implementation, math
Correct Solution:
```
a,b=map(int,input().split())
c=-(-a//2)
if a>=b:
for i in range(b):
if (c+i)%b==0:
print(c+i)
else:
print(-1)
``` | output | 1 | 81,177 | 8 | 162,355 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
Dreamoon wants to climb up a stair of n steps. He can climb 1 or 2 steps at each move. Dreamoon wants the number of moves to be a multiple of an integer m.
What is the minimal number of moves making him climb to the top of the stairs that satisfies his condition?
Input
The single line contains two space separated integers n, m (0 < n ≤ 10000, 1 < m ≤ 10).
Output
Print a single integer — the minimal number of moves being a multiple of m. If there is no way he can climb satisfying condition print - 1 instead.
Examples
Input
10 2
Output
6
Input
3 5
Output
-1
Note
For the first sample, Dreamoon could climb in 6 moves with following sequence of steps: {2, 2, 2, 2, 1, 1}.
For the second sample, there are only three valid sequence of steps {2, 1}, {1, 2}, {1, 1, 1} with 2, 2, and 3 steps respectively. All these numbers are not multiples of 5.
Submitted Solution:
```
# You lost the game.
n, m = map(int, input().split())
maximum = n
minimum = 1+(n-1)//2
k = minimum
while k <= maximum and k % m:
k += 1
if k <= maximum:
print(k)
else:
print(-1)
``` | instruction | 0 | 81,178 | 8 | 162,356 |
Yes | output | 1 | 81,178 | 8 | 162,357 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
Dreamoon wants to climb up a stair of n steps. He can climb 1 or 2 steps at each move. Dreamoon wants the number of moves to be a multiple of an integer m.
What is the minimal number of moves making him climb to the top of the stairs that satisfies his condition?
Input
The single line contains two space separated integers n, m (0 < n ≤ 10000, 1 < m ≤ 10).
Output
Print a single integer — the minimal number of moves being a multiple of m. If there is no way he can climb satisfying condition print - 1 instead.
Examples
Input
10 2
Output
6
Input
3 5
Output
-1
Note
For the first sample, Dreamoon could climb in 6 moves with following sequence of steps: {2, 2, 2, 2, 1, 1}.
For the second sample, there are only three valid sequence of steps {2, 1}, {1, 2}, {1, 1, 1} with 2, 2, and 3 steps respectively. All these numbers are not multiples of 5.
Submitted Solution:
```
def dreamoon_and_stairs(n, m):
k = n // 2
d = []
for i in range(0, k+1):
if (n-i)%m==0:
d.append(n-i)
if len (d)<= 0:
return -1
else:
return min(d)
# --------------------------------------------------------------
if __name__ == '__main__':
f = lambda: map(int, input().split())
s,t = f()
print(dreamoon_and_stairs(s,t))
``` | instruction | 0 | 81,179 | 8 | 162,358 |
Yes | output | 1 | 81,179 | 8 | 162,359 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
Dreamoon wants to climb up a stair of n steps. He can climb 1 or 2 steps at each move. Dreamoon wants the number of moves to be a multiple of an integer m.
What is the minimal number of moves making him climb to the top of the stairs that satisfies his condition?
Input
The single line contains two space separated integers n, m (0 < n ≤ 10000, 1 < m ≤ 10).
Output
Print a single integer — the minimal number of moves being a multiple of m. If there is no way he can climb satisfying condition print - 1 instead.
Examples
Input
10 2
Output
6
Input
3 5
Output
-1
Note
For the first sample, Dreamoon could climb in 6 moves with following sequence of steps: {2, 2, 2, 2, 1, 1}.
For the second sample, there are only three valid sequence of steps {2, 1}, {1, 2}, {1, 1, 1} with 2, 2, and 3 steps respectively. All these numbers are not multiples of 5.
Submitted Solution:
```
# -*- coding: utf-8 -*-
"""
Created on Sun Oct 28 10:33:21 2018
@author: Quaint Sun
"""
n,m=map(int,input().split())
if n<m:
print(-1)
else:
if (n/2)%m==0:
print(int(((n/2)//m)*m))
else:
print(int(((n/2)//m+1)*m))
``` | instruction | 0 | 81,180 | 8 | 162,360 |
Yes | output | 1 | 81,180 | 8 | 162,361 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
Dreamoon wants to climb up a stair of n steps. He can climb 1 or 2 steps at each move. Dreamoon wants the number of moves to be a multiple of an integer m.
What is the minimal number of moves making him climb to the top of the stairs that satisfies his condition?
Input
The single line contains two space separated integers n, m (0 < n ≤ 10000, 1 < m ≤ 10).
Output
Print a single integer — the minimal number of moves being a multiple of m. If there is no way he can climb satisfying condition print - 1 instead.
Examples
Input
10 2
Output
6
Input
3 5
Output
-1
Note
For the first sample, Dreamoon could climb in 6 moves with following sequence of steps: {2, 2, 2, 2, 1, 1}.
For the second sample, there are only three valid sequence of steps {2, 1}, {1, 2}, {1, 1, 1} with 2, 2, and 3 steps respectively. All these numbers are not multiples of 5.
Submitted Solution:
```
z=list(map(int,input().split()))
status=True
count=0
if z[0]%2==0 :
s=z[0]//2
else :
s=z[0]//2+1
while status :
if (s+count)%z[1]!=0 :
count+=1
else :
if (s+count) <= z[0] :
print(s+count)
status=False
else :
print(-1)
status=False
``` | instruction | 0 | 81,181 | 8 | 162,362 |
Yes | output | 1 | 81,181 | 8 | 162,363 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
Dreamoon wants to climb up a stair of n steps. He can climb 1 or 2 steps at each move. Dreamoon wants the number of moves to be a multiple of an integer m.
What is the minimal number of moves making him climb to the top of the stairs that satisfies his condition?
Input
The single line contains two space separated integers n, m (0 < n ≤ 10000, 1 < m ≤ 10).
Output
Print a single integer — the minimal number of moves being a multiple of m. If there is no way he can climb satisfying condition print - 1 instead.
Examples
Input
10 2
Output
6
Input
3 5
Output
-1
Note
For the first sample, Dreamoon could climb in 6 moves with following sequence of steps: {2, 2, 2, 2, 1, 1}.
For the second sample, there are only three valid sequence of steps {2, 1}, {1, 2}, {1, 1, 1} with 2, 2, and 3 steps respectively. All these numbers are not multiples of 5.
Submitted Solution:
```
# -*- coding: utf-8 -*-
"""
Created on Thu Jul 11 10:12:32 2019
@author: avina
"""
n,m = map(int, input().split())
if n%m == 0:
print(n//2 + 1)
else:
print(-1)
``` | instruction | 0 | 81,182 | 8 | 162,364 |
No | output | 1 | 81,182 | 8 | 162,365 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
Dreamoon wants to climb up a stair of n steps. He can climb 1 or 2 steps at each move. Dreamoon wants the number of moves to be a multiple of an integer m.
What is the minimal number of moves making him climb to the top of the stairs that satisfies his condition?
Input
The single line contains two space separated integers n, m (0 < n ≤ 10000, 1 < m ≤ 10).
Output
Print a single integer — the minimal number of moves being a multiple of m. If there is no way he can climb satisfying condition print - 1 instead.
Examples
Input
10 2
Output
6
Input
3 5
Output
-1
Note
For the first sample, Dreamoon could climb in 6 moves with following sequence of steps: {2, 2, 2, 2, 1, 1}.
For the second sample, there are only three valid sequence of steps {2, 1}, {1, 2}, {1, 1, 1} with 2, 2, and 3 steps respectively. All these numbers are not multiples of 5.
Submitted Solution:
```
# Dreamoon and Stairs
n,m=map(int,input().split())
if n<m:
print(-1)
else:
q=n//2
r=n%2
c=q+r
if c%m==0:
print(c)
else:
i=1
while q!=0 and c%m!=0:
q-=i
r+=i*2
c=q+r
print(c)
if c%m==0:
print(c)
else:
print(-1)
``` | instruction | 0 | 81,183 | 8 | 162,366 |
No | output | 1 | 81,183 | 8 | 162,367 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
Dreamoon wants to climb up a stair of n steps. He can climb 1 or 2 steps at each move. Dreamoon wants the number of moves to be a multiple of an integer m.
What is the minimal number of moves making him climb to the top of the stairs that satisfies his condition?
Input
The single line contains two space separated integers n, m (0 < n ≤ 10000, 1 < m ≤ 10).
Output
Print a single integer — the minimal number of moves being a multiple of m. If there is no way he can climb satisfying condition print - 1 instead.
Examples
Input
10 2
Output
6
Input
3 5
Output
-1
Note
For the first sample, Dreamoon could climb in 6 moves with following sequence of steps: {2, 2, 2, 2, 1, 1}.
For the second sample, there are only three valid sequence of steps {2, 1}, {1, 2}, {1, 1, 1} with 2, 2, and 3 steps respectively. All these numbers are not multiples of 5.
Submitted Solution:
```
__author__ = 'Лицеист'
inp=input().split(" ")
l=[]
n=int(inp[0])
m=int(inp[1])
if m>n:
print(-1)
else:
if n%2 == 0:
k=n/2
else:
k=n/2+1
if k%m==0:
print(k)
else:
q=k%m
z=k+q
print(z)
``` | instruction | 0 | 81,184 | 8 | 162,368 |
No | output | 1 | 81,184 | 8 | 162,369 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
Dreamoon wants to climb up a stair of n steps. He can climb 1 or 2 steps at each move. Dreamoon wants the number of moves to be a multiple of an integer m.
What is the minimal number of moves making him climb to the top of the stairs that satisfies his condition?
Input
The single line contains two space separated integers n, m (0 < n ≤ 10000, 1 < m ≤ 10).
Output
Print a single integer — the minimal number of moves being a multiple of m. If there is no way he can climb satisfying condition print - 1 instead.
Examples
Input
10 2
Output
6
Input
3 5
Output
-1
Note
For the first sample, Dreamoon could climb in 6 moves with following sequence of steps: {2, 2, 2, 2, 1, 1}.
For the second sample, there are only three valid sequence of steps {2, 1}, {1, 2}, {1, 1, 1} with 2, 2, and 3 steps respectively. All these numbers are not multiples of 5.
Submitted Solution:
```
input_string = input ('Введите n,m\n')
n,m = input_string.split ()
n,m = int (n), int (m)
min_steps = [0]
for i in range (1,10001):
min_steps.append (-1)
for i in range (1,10001):
max = i
min = i//2 + i%2
for j in range (min,max+1):
if j%m == 0:
min_steps [i] = j
break
print (min_steps [n])
``` | instruction | 0 | 81,185 | 8 | 162,370 |
No | output | 1 | 81,185 | 8 | 162,371 |
Provide tags and a correct Python 3 solution for this coding contest problem.
Heidi the Cow is aghast: cracks in the northern Wall? Zombies gathering outside, forming groups, preparing their assault? This must not happen! Quickly, she fetches her HC2 (Handbook of Crazy Constructions) and looks for the right chapter:
How to build a wall:
1. Take a set of bricks.
2. Select one of the possible wall designs. Computing the number of possible designs is left as an exercise to the reader.
3. Place bricks on top of each other, according to the chosen design.
This seems easy enough. But Heidi is a Coding Cow, not a Constructing Cow. Her mind keeps coming back to point 2b. Despite the imminent danger of a zombie onslaught, she wonders just how many possible walls she could build with up to n bricks.
A wall is a set of wall segments as defined in the easy version. How many different walls can be constructed such that the wall consists of at least 1 and at most n bricks? Two walls are different if there exist a column c and a row r such that one wall has a brick in this spot, and the other does not.
Along with n, you will be given C, the width of the wall (as defined in the easy version). Return the number of different walls modulo 106 + 3.
Input
The first line contains two space-separated integers n and C, 1 ≤ n ≤ 500000, 1 ≤ C ≤ 200000.
Output
Print the number of different walls that Heidi could build, modulo 106 + 3.
Examples
Input
5 1
Output
5
Input
2 2
Output
5
Input
3 2
Output
9
Input
11 5
Output
4367
Input
37 63
Output
230574
Note
The number 106 + 3 is prime.
In the second sample case, the five walls are:
B B
B., .B, BB, B., and .B
In the third sample case, the nine walls are the five as in the second sample case and in addition the following four:
B B
B B B B
B., .B, BB, and BB
| instruction | 0 | 81,292 | 8 | 162,584 |
Tags: combinatorics
Correct Solution:
```
n, c = map(int, input().split())
mod = 10 ** 6 +3
inv = [0, 1]
for i in range(2, max(n, c) + 1):
inv.append(inv[mod % i] * (mod - mod // i) % mod)
ans = 1
for i in range(1, n + c + 1):
ans = ans * i % mod
for i in range(1, c + 1):
ans = ans * inv[i] % mod
for i in range(1, n + 1):
ans = ans * inv[i] % mod
ans += mod - 1
ans %= mod
print(ans)
``` | output | 1 | 81,292 | 8 | 162,585 |
Provide tags and a correct Python 3 solution for this coding contest problem.
Heidi the Cow is aghast: cracks in the northern Wall? Zombies gathering outside, forming groups, preparing their assault? This must not happen! Quickly, she fetches her HC2 (Handbook of Crazy Constructions) and looks for the right chapter:
How to build a wall:
1. Take a set of bricks.
2. Select one of the possible wall designs. Computing the number of possible designs is left as an exercise to the reader.
3. Place bricks on top of each other, according to the chosen design.
This seems easy enough. But Heidi is a Coding Cow, not a Constructing Cow. Her mind keeps coming back to point 2b. Despite the imminent danger of a zombie onslaught, she wonders just how many possible walls she could build with up to n bricks.
A wall is a set of wall segments as defined in the easy version. How many different walls can be constructed such that the wall consists of at least 1 and at most n bricks? Two walls are different if there exist a column c and a row r such that one wall has a brick in this spot, and the other does not.
Along with n, you will be given C, the width of the wall (as defined in the easy version). Return the number of different walls modulo 106 + 3.
Input
The first line contains two space-separated integers n and C, 1 ≤ n ≤ 500000, 1 ≤ C ≤ 200000.
Output
Print the number of different walls that Heidi could build, modulo 106 + 3.
Examples
Input
5 1
Output
5
Input
2 2
Output
5
Input
3 2
Output
9
Input
11 5
Output
4367
Input
37 63
Output
230574
Note
The number 106 + 3 is prime.
In the second sample case, the five walls are:
B B
B., .B, BB, B., and .B
In the third sample case, the nine walls are the five as in the second sample case and in addition the following four:
B B
B B B B
B., .B, BB, and BB
| instruction | 0 | 81,293 | 8 | 162,586 |
Tags: combinatorics
Correct Solution:
```
M = pow(10,6) + 3
def wall(n,c):
fact = factorial(n+c)
_,inv_n,_ = extended_euclidean_alg_1(fact[n],M)
_,inv_c,_ = extended_euclidean_alg_1(fact[c],M)
return (((((fact[n+c] * (inv_n % M)) % M) * (inv_c % M)) % M) - 1)% M
def factorial(m):
facts = [1 for _ in range(m+1)]
for n in range(1,m+1):
facts[n] = (facts[n-1] * n) % M
return facts
def extended_euclidean_alg_1(a,b):
if not b:
return 0,1,0
u0,u1 = 1,0
v0,v1 = 0,1
while b:
q = a//b
r = a - b * q
u = u0 - q * u1
v = v0 - q * v1
#Update a,b
a = b
b = r
#Update for next iteration
u0 = u1
u1 = u
v0 = v1
v1 = v
return a, u0, v0
def main():
n,c = [int(i) for i in input().split()]
count = wall(n,c)
print(int(count))
main()
``` | output | 1 | 81,293 | 8 | 162,587 |
Provide tags and a correct Python 3 solution for this coding contest problem.
Heidi the Cow is aghast: cracks in the northern Wall? Zombies gathering outside, forming groups, preparing their assault? This must not happen! Quickly, she fetches her HC2 (Handbook of Crazy Constructions) and looks for the right chapter:
How to build a wall:
1. Take a set of bricks.
2. Select one of the possible wall designs. Computing the number of possible designs is left as an exercise to the reader.
3. Place bricks on top of each other, according to the chosen design.
This seems easy enough. But Heidi is a Coding Cow, not a Constructing Cow. Her mind keeps coming back to point 2b. Despite the imminent danger of a zombie onslaught, she wonders just how many possible walls she could build with up to n bricks.
A wall is a set of wall segments as defined in the easy version. How many different walls can be constructed such that the wall consists of at least 1 and at most n bricks? Two walls are different if there exist a column c and a row r such that one wall has a brick in this spot, and the other does not.
Along with n, you will be given C, the width of the wall (as defined in the easy version). Return the number of different walls modulo 106 + 3.
Input
The first line contains two space-separated integers n and C, 1 ≤ n ≤ 500000, 1 ≤ C ≤ 200000.
Output
Print the number of different walls that Heidi could build, modulo 106 + 3.
Examples
Input
5 1
Output
5
Input
2 2
Output
5
Input
3 2
Output
9
Input
11 5
Output
4367
Input
37 63
Output
230574
Note
The number 106 + 3 is prime.
In the second sample case, the five walls are:
B B
B., .B, BB, B., and .B
In the third sample case, the nine walls are the five as in the second sample case and in addition the following four:
B B
B B B B
B., .B, BB, and BB
| instruction | 0 | 81,294 | 8 | 162,588 |
Tags: combinatorics
Correct Solution:
```
import math
import operator as op
from functools import reduce
from operator import mul # or mul=lambda x,y:x*y
from fractions import Fraction
def nCk(n,k):
return int( reduce(mul, (Fraction(n-i, i+1) for i in range(k)), 1) )
def ncr(n, r):
r = min(r, n-r)
if r == 0: return 1
numer = reduce(op.mul, range(n, n-r, -1))
denom = reduce(op.mul, range(1, r+1))
return numer//denom
def modPow(a, x, p):
#calculates a^x mod p in logarithmic time.
res = 1
while(x > 0):
if( x % 2 != 0):
res = (res * a) % p
a = (a * a) % p
x = int(x/2)
return res
def modInverse(a, p):
#calculates the modular multiplicative of a mod m.
#(assuming p is prime).
return modPow(a, p-2, p)
def modBinomial(n, k, p):
#calculates C(n,k) mod p (assuming p is prime).
# n * (n-1) * ... * (n-k+1)
numerator = 1
for i in range(k):
numerator = (numerator * (n-i) ) % p
denominator = 1
for i in range(1, k+1):
denominator = (denominator * i) % p
# numerator / denominator mod p.
return ( numerator* modInverse(denominator,p) ) % p
n, c = input().split()
n = int(n)
c = int(c)
#test = [0 for x in range (n+1)]
#test[1] = c
#for i in range(2, n+1):
# test[i] = (test[i-1] + modBinomial((i+c-1),i, 1000003))%1000003
#ans = solve(n, c)
#ans =test[n]
ans = modBinomial((c+n),c,1000003) - 1
print(int(ans))
``` | output | 1 | 81,294 | 8 | 162,589 |
Provide tags and a correct Python 3 solution for this coding contest problem.
Heidi the Cow is aghast: cracks in the northern Wall? Zombies gathering outside, forming groups, preparing their assault? This must not happen! Quickly, she fetches her HC2 (Handbook of Crazy Constructions) and looks for the right chapter:
How to build a wall:
1. Take a set of bricks.
2. Select one of the possible wall designs. Computing the number of possible designs is left as an exercise to the reader.
3. Place bricks on top of each other, according to the chosen design.
This seems easy enough. But Heidi is a Coding Cow, not a Constructing Cow. Her mind keeps coming back to point 2b. Despite the imminent danger of a zombie onslaught, she wonders just how many possible walls she could build with up to n bricks.
A wall is a set of wall segments as defined in the easy version. How many different walls can be constructed such that the wall consists of at least 1 and at most n bricks? Two walls are different if there exist a column c and a row r such that one wall has a brick in this spot, and the other does not.
Along with n, you will be given C, the width of the wall (as defined in the easy version). Return the number of different walls modulo 106 + 3.
Input
The first line contains two space-separated integers n and C, 1 ≤ n ≤ 500000, 1 ≤ C ≤ 200000.
Output
Print the number of different walls that Heidi could build, modulo 106 + 3.
Examples
Input
5 1
Output
5
Input
2 2
Output
5
Input
3 2
Output
9
Input
11 5
Output
4367
Input
37 63
Output
230574
Note
The number 106 + 3 is prime.
In the second sample case, the five walls are:
B B
B., .B, BB, B., and .B
In the third sample case, the nine walls are the five as in the second sample case and in addition the following four:
B B
B B B B
B., .B, BB, and BB
| instruction | 0 | 81,295 | 8 | 162,590 |
Tags: combinatorics
Correct Solution:
```
def fact(n, mod):
'''
Calcula el factorial de n modulo mod
:param n: int
:param mod: int
:return: int
'''
ans = 1
for i in range(1, n + 1):
ans = ans * i % mod
return ans
def inv1(n, mod):
'''
Calcula el inverso de n modulo mod usando el pequenno teorema de fermat
:param n:
:param mod:
:return:
'''
ans = 1
for i in range(mod - 2):
ans = ans * n % mod
return ans
def inv2(n, mod):
'''
Calcula el inverso de n modulo mod usando el pequenno teorema de fermat
y la funcion pow del sistema
:param n:
:param mod:
:return:
'''
return pow(n, mod - 2, mod)
mod = 1000003
n, c = [int(i) for i in input().split()]
a = fact(n + c, mod)
b = fact(n, mod)
c = fact(c, mod)
b = inv1(b, mod)
c = inv2(c, mod)
ans = a * b % mod * c % mod
ans -= 1
if ans < 0: ans += mod
print(ans)
``` | output | 1 | 81,295 | 8 | 162,591 |
Provide tags and a correct Python 3 solution for this coding contest problem.
Heidi the Cow is aghast: cracks in the northern Wall? Zombies gathering outside, forming groups, preparing their assault? This must not happen! Quickly, she fetches her HC2 (Handbook of Crazy Constructions) and looks for the right chapter:
How to build a wall:
1. Take a set of bricks.
2. Select one of the possible wall designs. Computing the number of possible designs is left as an exercise to the reader.
3. Place bricks on top of each other, according to the chosen design.
This seems easy enough. But Heidi is a Coding Cow, not a Constructing Cow. Her mind keeps coming back to point 2b. Despite the imminent danger of a zombie onslaught, she wonders just how many possible walls she could build with up to n bricks.
A wall is a set of wall segments as defined in the easy version. How many different walls can be constructed such that the wall consists of at least 1 and at most n bricks? Two walls are different if there exist a column c and a row r such that one wall has a brick in this spot, and the other does not.
Along with n, you will be given C, the width of the wall (as defined in the easy version). Return the number of different walls modulo 106 + 3.
Input
The first line contains two space-separated integers n and C, 1 ≤ n ≤ 500000, 1 ≤ C ≤ 200000.
Output
Print the number of different walls that Heidi could build, modulo 106 + 3.
Examples
Input
5 1
Output
5
Input
2 2
Output
5
Input
3 2
Output
9
Input
11 5
Output
4367
Input
37 63
Output
230574
Note
The number 106 + 3 is prime.
In the second sample case, the five walls are:
B B
B., .B, BB, B., and .B
In the third sample case, the nine walls are the five as in the second sample case and in addition the following four:
B B
B B B B
B., .B, BB, and BB
| instruction | 0 | 81,296 | 8 | 162,592 |
Tags: combinatorics
Correct Solution:
```
result=0 # variable que va a guardar el resultado del problema
mod=10**6 +3 # la respuesta se debe dar modulo este numero
n,C=map(int,input().split()) #recibimos la entrada
#calc n!
def fact(n): # calcular el factorial de n modulo mod
fact=1
for i in range(1,n+1): #1*2*3*...*n = n*(n-1)*(n-2)...*1
fact=(fact*i)%mod # cada vez que multiplicamos lo hacemos modulo mod
return fact #devolvemos factorial de n
def pow(a,b): #Algoritmo de Exponenciacion binaria modular
exp=1 # Caso base a^1=a
x=a % mod # dado que el a de entrada puede ser bastante grande y la respuesta se debe dar modulo mod hacemos a modulo mod
b=b%(mod-1) # # como mod es primo para a^b % p hacemos a^{b%(p-1)} %p
while b > 0:
if b % 2 == 1:# En caso que b sea impar
exp=(exp*x)%mod
x=(x*x)%mod
b=b//2
return exp
#cacl (n+C)!/(n!*C!) , usamos el peque{~}no teorema de Fermat a^{p-1}congruente 1(p) a^{p-2}congruente a^{-1}(p)
# de esta forma en vez de 1/n! modulo p y 1/C! modulo p usamos n!**p-2 modulo mod y C!**p-2 modulo p en este caso p=mod
result=fact(n+C)*pow(fact(n),mod-2)*pow(fact(C),mod-2)-1 # C(n+C,C)= n+C!
print(int(result%mod)) # imprimimos la salida del problema
``` | output | 1 | 81,296 | 8 | 162,593 |
Provide tags and a correct Python 3 solution for this coding contest problem.
Heidi the Cow is aghast: cracks in the northern Wall? Zombies gathering outside, forming groups, preparing their assault? This must not happen! Quickly, she fetches her HC2 (Handbook of Crazy Constructions) and looks for the right chapter:
How to build a wall:
1. Take a set of bricks.
2. Select one of the possible wall designs. Computing the number of possible designs is left as an exercise to the reader.
3. Place bricks on top of each other, according to the chosen design.
This seems easy enough. But Heidi is a Coding Cow, not a Constructing Cow. Her mind keeps coming back to point 2b. Despite the imminent danger of a zombie onslaught, she wonders just how many possible walls she could build with up to n bricks.
A wall is a set of wall segments as defined in the easy version. How many different walls can be constructed such that the wall consists of at least 1 and at most n bricks? Two walls are different if there exist a column c and a row r such that one wall has a brick in this spot, and the other does not.
Along with n, you will be given C, the width of the wall (as defined in the easy version). Return the number of different walls modulo 106 + 3.
Input
The first line contains two space-separated integers n and C, 1 ≤ n ≤ 500000, 1 ≤ C ≤ 200000.
Output
Print the number of different walls that Heidi could build, modulo 106 + 3.
Examples
Input
5 1
Output
5
Input
2 2
Output
5
Input
3 2
Output
9
Input
11 5
Output
4367
Input
37 63
Output
230574
Note
The number 106 + 3 is prime.
In the second sample case, the five walls are:
B B
B., .B, BB, B., and .B
In the third sample case, the nine walls are the five as in the second sample case and in addition the following four:
B B
B B B B
B., .B, BB, and BB
| instruction | 0 | 81,297 | 8 | 162,594 |
Tags: combinatorics
Correct Solution:
```
result=0
mod=10**6 +3
n,C=map(int,input().split()) #recibimos la entrada
#calc n!
def fact(n):
fact=1
for i in range(1,n+1): #1*2*3*...*n = n*(n-1)*(n-2)...*1
fact=(fact*i)%mod #
return fact
def pow(a,b): #Algoritmo de Exponenciacion binaria
exp=1 # Caso base a^1=a
x=a % mod
while b > 0:
if b % 2 == 1:# En caso que b sea impar
exp=(exp*x)%mod
# En caso que b sea impar
x=(x*x)%mod
b=b//2
return exp
#cacl (n+C)!/(n!*C!) , usamos el pequenno teorema de Fermat a^{p-1}congruente 1(p) a^{p-2}congruente a^{-1}(p)
# de esta forma en vez de 1/n! y 1/C! usamos n!**p-2 C!**p-2 en este caso p=mod
result=fact(n+C)*pow(fact(n),mod-2)*pow(fact(C),mod-2)-1 # C(n+C,C)= n+C!
print(int(result%mod))
``` | output | 1 | 81,297 | 8 | 162,595 |
Provide tags and a correct Python 3 solution for this coding contest problem.
Heidi the Cow is aghast: cracks in the northern Wall? Zombies gathering outside, forming groups, preparing their assault? This must not happen! Quickly, she fetches her HC2 (Handbook of Crazy Constructions) and looks for the right chapter:
How to build a wall:
1. Take a set of bricks.
2. Select one of the possible wall designs. Computing the number of possible designs is left as an exercise to the reader.
3. Place bricks on top of each other, according to the chosen design.
This seems easy enough. But Heidi is a Coding Cow, not a Constructing Cow. Her mind keeps coming back to point 2b. Despite the imminent danger of a zombie onslaught, she wonders just how many possible walls she could build with up to n bricks.
A wall is a set of wall segments as defined in the easy version. How many different walls can be constructed such that the wall consists of at least 1 and at most n bricks? Two walls are different if there exist a column c and a row r such that one wall has a brick in this spot, and the other does not.
Along with n, you will be given C, the width of the wall (as defined in the easy version). Return the number of different walls modulo 106 + 3.
Input
The first line contains two space-separated integers n and C, 1 ≤ n ≤ 500000, 1 ≤ C ≤ 200000.
Output
Print the number of different walls that Heidi could build, modulo 106 + 3.
Examples
Input
5 1
Output
5
Input
2 2
Output
5
Input
3 2
Output
9
Input
11 5
Output
4367
Input
37 63
Output
230574
Note
The number 106 + 3 is prime.
In the second sample case, the five walls are:
B B
B., .B, BB, B., and .B
In the third sample case, the nine walls are the five as in the second sample case and in addition the following four:
B B
B B B B
B., .B, BB, and BB
| instruction | 0 | 81,298 | 8 | 162,596 |
Tags: combinatorics
Correct Solution:
```
import sys
MOD = 10**6+3 # el modulo que es un numero primo
fact = [1] * (7* 10**5 + 10) #un array de tamano 7* 10**5 + 10 para guaradar los valores del factorial precalculado
# para calcular el factorial modulo MOD hasta la cuota superior que es 5*10^5 + 2 * 10^5
for i in range (1,len(fact)):
fact[i] = (fact[i-1] * i) % MOD
# Calcula el Coeficiente binomico modulo MOD
def Binom(n,k):
return (fact[n] * (pow (fact[n-k] , MOD -2,MOD)*pow (fact[k] , MOD -2,MOD)) % MOD)%MOD
def solution(n,C):
return (Binom(n+C,C)) -1 # calcular el coeficiente binomico n+c en c y restarle el caso en el que el muro no tiene bloques , que es la s
if __name__ == "__main__":
n,c = map(int,input().split())
print(solution(n,c))
``` | output | 1 | 81,298 | 8 | 162,597 |
Provide tags and a correct Python 3 solution for this coding contest problem.
Heidi the Cow is aghast: cracks in the northern Wall? Zombies gathering outside, forming groups, preparing their assault? This must not happen! Quickly, she fetches her HC2 (Handbook of Crazy Constructions) and looks for the right chapter:
How to build a wall:
1. Take a set of bricks.
2. Select one of the possible wall designs. Computing the number of possible designs is left as an exercise to the reader.
3. Place bricks on top of each other, according to the chosen design.
This seems easy enough. But Heidi is a Coding Cow, not a Constructing Cow. Her mind keeps coming back to point 2b. Despite the imminent danger of a zombie onslaught, she wonders just how many possible walls she could build with up to n bricks.
A wall is a set of wall segments as defined in the easy version. How many different walls can be constructed such that the wall consists of at least 1 and at most n bricks? Two walls are different if there exist a column c and a row r such that one wall has a brick in this spot, and the other does not.
Along with n, you will be given C, the width of the wall (as defined in the easy version). Return the number of different walls modulo 106 + 3.
Input
The first line contains two space-separated integers n and C, 1 ≤ n ≤ 500000, 1 ≤ C ≤ 200000.
Output
Print the number of different walls that Heidi could build, modulo 106 + 3.
Examples
Input
5 1
Output
5
Input
2 2
Output
5
Input
3 2
Output
9
Input
11 5
Output
4367
Input
37 63
Output
230574
Note
The number 106 + 3 is prime.
In the second sample case, the five walls are:
B B
B., .B, BB, B., and .B
In the third sample case, the nine walls are the five as in the second sample case and in addition the following four:
B B
B B B B
B., .B, BB, and BB
| instruction | 0 | 81,299 | 8 | 162,598 |
Tags: combinatorics
Correct Solution:
```
result=0
mod=10**6 +3
n,C=map(int,input().split()) #recibimos la entrada
#calc n!
def fact(n):
fact=1
for i in range(1,n+1): #1*2*3*...*n = n*(n-1)*(n-2)...*1
fact=(fact*i)%mod #
return fact
def pow(a,b): #Algoritmo de Exponenciacion binaria
exp=1 # Caso base a^1=a
x=a % mod
b=b%(mod-1)
while b > 0:
if b % 2 == 1:# En caso que b sea impar
exp=(exp*x)%mod
# En caso que b sea impar
x=(x*x)%mod
b=b//2
return exp
#cacl (n+C)!/(n!*C!) , usamos el pequenno teorema de Fermat a^{p-1}congruente 1(p) a^{p-2}congruente a^{-1}(p)
# de esta forma en vez de 1/n! y 1/C! usamos n!**p-2 C!**p-2 en este caso p=mod
result=fact(n+C)*pow(fact(n),mod-2)*pow(fact(C),mod-2)-1 # C(n+C,C)= n+C!
print(int(result%mod))
``` | output | 1 | 81,299 | 8 | 162,599 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
Heidi the Cow is aghast: cracks in the northern Wall? Zombies gathering outside, forming groups, preparing their assault? This must not happen! Quickly, she fetches her HC2 (Handbook of Crazy Constructions) and looks for the right chapter:
How to build a wall:
1. Take a set of bricks.
2. Select one of the possible wall designs. Computing the number of possible designs is left as an exercise to the reader.
3. Place bricks on top of each other, according to the chosen design.
This seems easy enough. But Heidi is a Coding Cow, not a Constructing Cow. Her mind keeps coming back to point 2b. Despite the imminent danger of a zombie onslaught, she wonders just how many possible walls she could build with up to n bricks.
A wall is a set of wall segments as defined in the easy version. How many different walls can be constructed such that the wall consists of at least 1 and at most n bricks? Two walls are different if there exist a column c and a row r such that one wall has a brick in this spot, and the other does not.
Along with n, you will be given C, the width of the wall (as defined in the easy version). Return the number of different walls modulo 106 + 3.
Input
The first line contains two space-separated integers n and C, 1 ≤ n ≤ 500000, 1 ≤ C ≤ 200000.
Output
Print the number of different walls that Heidi could build, modulo 106 + 3.
Examples
Input
5 1
Output
5
Input
2 2
Output
5
Input
3 2
Output
9
Input
11 5
Output
4367
Input
37 63
Output
230574
Note
The number 106 + 3 is prime.
In the second sample case, the five walls are:
B B
B., .B, BB, B., and .B
In the third sample case, the nine walls are the five as in the second sample case and in addition the following four:
B B
B B B B
B., .B, BB, and BB
Submitted Solution:
```
M = pow(10,6) + 3
def wall(n,c):
fact = factorial(n+c)
inv_n = pow(fact[n],M-2,M)
inv_c= pow(fact[c],M-2,M)
return (((((fact[n+c] * (inv_n % M)) % M) * (inv_c % M)) % M) - 1)% M
def factorial(m):
facts = [1 for _ in range(m+1)]
for n in range(1,m+1):
facts[n] = (facts[n-1] * n) % M
return facts
def main():
n,c = [int(i) for i in input().split()]
count = wall(n,c)
print(int(count))
main()
``` | instruction | 0 | 81,300 | 8 | 162,600 |
Yes | output | 1 | 81,300 | 8 | 162,601 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
Heidi the Cow is aghast: cracks in the northern Wall? Zombies gathering outside, forming groups, preparing their assault? This must not happen! Quickly, she fetches her HC2 (Handbook of Crazy Constructions) and looks for the right chapter:
How to build a wall:
1. Take a set of bricks.
2. Select one of the possible wall designs. Computing the number of possible designs is left as an exercise to the reader.
3. Place bricks on top of each other, according to the chosen design.
This seems easy enough. But Heidi is a Coding Cow, not a Constructing Cow. Her mind keeps coming back to point 2b. Despite the imminent danger of a zombie onslaught, she wonders just how many possible walls she could build with up to n bricks.
A wall is a set of wall segments as defined in the easy version. How many different walls can be constructed such that the wall consists of at least 1 and at most n bricks? Two walls are different if there exist a column c and a row r such that one wall has a brick in this spot, and the other does not.
Along with n, you will be given C, the width of the wall (as defined in the easy version). Return the number of different walls modulo 106 + 3.
Input
The first line contains two space-separated integers n and C, 1 ≤ n ≤ 500000, 1 ≤ C ≤ 200000.
Output
Print the number of different walls that Heidi could build, modulo 106 + 3.
Examples
Input
5 1
Output
5
Input
2 2
Output
5
Input
3 2
Output
9
Input
11 5
Output
4367
Input
37 63
Output
230574
Note
The number 106 + 3 is prime.
In the second sample case, the five walls are:
B B
B., .B, BB, B., and .B
In the third sample case, the nine walls are the five as in the second sample case and in addition the following four:
B B
B B B B
B., .B, BB, and BB
Submitted Solution:
```
import math
m = int(1e6 + 3)
a,b = input().split()
a = int(a)
b = int(b)
A = 1
B = 1
for i in range(2,a + b + 1):
A=(A*i)%m
if i<=a:
B=(B*i)%m
if i<=b:
B=(B*i)%m
print((A*pow(B,m-2,m)-1)%m)
``` | instruction | 0 | 81,301 | 8 | 162,602 |
Yes | output | 1 | 81,301 | 8 | 162,603 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
Heidi the Cow is aghast: cracks in the northern Wall? Zombies gathering outside, forming groups, preparing their assault? This must not happen! Quickly, she fetches her HC2 (Handbook of Crazy Constructions) and looks for the right chapter:
How to build a wall:
1. Take a set of bricks.
2. Select one of the possible wall designs. Computing the number of possible designs is left as an exercise to the reader.
3. Place bricks on top of each other, according to the chosen design.
This seems easy enough. But Heidi is a Coding Cow, not a Constructing Cow. Her mind keeps coming back to point 2b. Despite the imminent danger of a zombie onslaught, she wonders just how many possible walls she could build with up to n bricks.
A wall is a set of wall segments as defined in the easy version. How many different walls can be constructed such that the wall consists of at least 1 and at most n bricks? Two walls are different if there exist a column c and a row r such that one wall has a brick in this spot, and the other does not.
Along with n, you will be given C, the width of the wall (as defined in the easy version). Return the number of different walls modulo 106 + 3.
Input
The first line contains two space-separated integers n and C, 1 ≤ n ≤ 500000, 1 ≤ C ≤ 200000.
Output
Print the number of different walls that Heidi could build, modulo 106 + 3.
Examples
Input
5 1
Output
5
Input
2 2
Output
5
Input
3 2
Output
9
Input
11 5
Output
4367
Input
37 63
Output
230574
Note
The number 106 + 3 is prime.
In the second sample case, the five walls are:
B B
B., .B, BB, B., and .B
In the third sample case, the nine walls are the five as in the second sample case and in addition the following four:
B B
B B B B
B., .B, BB, and BB
Submitted Solution:
```
import sys
#with open(filename, 'r') as f:
with sys.stdin as f:
n, C = f.readline().split(" ")
n, C = int(n), int(C)
p = 1000003
def compute_mod_fact(n, p):
# n! (mod p)
res = 1
for i in range(1, n+1):
res = (res * i) % p
return res
def compute_mod_mult(n, a, p):
# n**a (mod p)
res = 1
for _ in range(a):
res = (res * n) % p
return res
res = compute_mod_fact(n+C, p)
res1 = compute_mod_fact(n, p)
res1 = compute_mod_mult(res1, p-2, p)
res2 = compute_mod_fact(C, p)
res2 = compute_mod_mult(res2, p-2, p)
#print(res, res1, res2)
res = (res * res1 * res2 - 1) % p
print(res)
``` | instruction | 0 | 81,302 | 8 | 162,604 |
Yes | output | 1 | 81,302 | 8 | 162,605 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
Heidi the Cow is aghast: cracks in the northern Wall? Zombies gathering outside, forming groups, preparing their assault? This must not happen! Quickly, she fetches her HC2 (Handbook of Crazy Constructions) and looks for the right chapter:
How to build a wall:
1. Take a set of bricks.
2. Select one of the possible wall designs. Computing the number of possible designs is left as an exercise to the reader.
3. Place bricks on top of each other, according to the chosen design.
This seems easy enough. But Heidi is a Coding Cow, not a Constructing Cow. Her mind keeps coming back to point 2b. Despite the imminent danger of a zombie onslaught, she wonders just how many possible walls she could build with up to n bricks.
A wall is a set of wall segments as defined in the easy version. How many different walls can be constructed such that the wall consists of at least 1 and at most n bricks? Two walls are different if there exist a column c and a row r such that one wall has a brick in this spot, and the other does not.
Along with n, you will be given C, the width of the wall (as defined in the easy version). Return the number of different walls modulo 106 + 3.
Input
The first line contains two space-separated integers n and C, 1 ≤ n ≤ 500000, 1 ≤ C ≤ 200000.
Output
Print the number of different walls that Heidi could build, modulo 106 + 3.
Examples
Input
5 1
Output
5
Input
2 2
Output
5
Input
3 2
Output
9
Input
11 5
Output
4367
Input
37 63
Output
230574
Note
The number 106 + 3 is prime.
In the second sample case, the five walls are:
B B
B., .B, BB, B., and .B
In the third sample case, the nine walls are the five as in the second sample case and in addition the following four:
B B
B B B B
B., .B, BB, and BB
Submitted Solution:
```
result=0
mod=10**6 +3
n,C=map(int,input().split())
def fact(n):
fact=1
for i in range(1,n+1):
fact=(fact*i)%mod
return fact
def pow(a,b):
p=1
for i in range(b):
p=(a*p)% mod
return p
result=fact(n+C)*pow(fact(n),mod-2)*pow(fact(C),mod-2)-1
print(int(result%mod))
``` | instruction | 0 | 81,303 | 8 | 162,606 |
Yes | output | 1 | 81,303 | 8 | 162,607 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
Heidi the Cow is aghast: cracks in the northern Wall? Zombies gathering outside, forming groups, preparing their assault? This must not happen! Quickly, she fetches her HC2 (Handbook of Crazy Constructions) and looks for the right chapter:
How to build a wall:
1. Take a set of bricks.
2. Select one of the possible wall designs. Computing the number of possible designs is left as an exercise to the reader.
3. Place bricks on top of each other, according to the chosen design.
This seems easy enough. But Heidi is a Coding Cow, not a Constructing Cow. Her mind keeps coming back to point 2b. Despite the imminent danger of a zombie onslaught, she wonders just how many possible walls she could build with up to n bricks.
A wall is a set of wall segments as defined in the easy version. How many different walls can be constructed such that the wall consists of at least 1 and at most n bricks? Two walls are different if there exist a column c and a row r such that one wall has a brick in this spot, and the other does not.
Along with n, you will be given C, the width of the wall (as defined in the easy version). Return the number of different walls modulo 106 + 3.
Input
The first line contains two space-separated integers n and C, 1 ≤ n ≤ 500000, 1 ≤ C ≤ 200000.
Output
Print the number of different walls that Heidi could build, modulo 106 + 3.
Examples
Input
5 1
Output
5
Input
2 2
Output
5
Input
3 2
Output
9
Input
11 5
Output
4367
Input
37 63
Output
230574
Note
The number 106 + 3 is prime.
In the second sample case, the five walls are:
B B
B., .B, BB, B., and .B
In the third sample case, the nine walls are the five as in the second sample case and in addition the following four:
B B
B B B B
B., .B, BB, and BB
Submitted Solution:
```
result=0
n,C=map(int,input().split())
def BinCoefficient(n,k):
# since C(n, k) = C(n, n - k)
if(k > n - k):
k = n - k
# initialize result
res = 1
# Calculate value of
# [n * (n-1) *---* (n-k + 1)] / [k * (k-1) *----* 1]
for i in range(k):
res = res * (n - i)
res = res / (i + 1)
return int(res)
for i in range(1,n+1):
result+=BinCoefficient(i+C-1,C-1)
print(result)
``` | instruction | 0 | 81,304 | 8 | 162,608 |
No | output | 1 | 81,304 | 8 | 162,609 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
Heidi the Cow is aghast: cracks in the northern Wall? Zombies gathering outside, forming groups, preparing their assault? This must not happen! Quickly, she fetches her HC2 (Handbook of Crazy Constructions) and looks for the right chapter:
How to build a wall:
1. Take a set of bricks.
2. Select one of the possible wall designs. Computing the number of possible designs is left as an exercise to the reader.
3. Place bricks on top of each other, according to the chosen design.
This seems easy enough. But Heidi is a Coding Cow, not a Constructing Cow. Her mind keeps coming back to point 2b. Despite the imminent danger of a zombie onslaught, she wonders just how many possible walls she could build with up to n bricks.
A wall is a set of wall segments as defined in the easy version. How many different walls can be constructed such that the wall consists of at least 1 and at most n bricks? Two walls are different if there exist a column c and a row r such that one wall has a brick in this spot, and the other does not.
Along with n, you will be given C, the width of the wall (as defined in the easy version). Return the number of different walls modulo 106 + 3.
Input
The first line contains two space-separated integers n and C, 1 ≤ n ≤ 500000, 1 ≤ C ≤ 200000.
Output
Print the number of different walls that Heidi could build, modulo 106 + 3.
Examples
Input
5 1
Output
5
Input
2 2
Output
5
Input
3 2
Output
9
Input
11 5
Output
4367
Input
37 63
Output
230574
Note
The number 106 + 3 is prime.
In the second sample case, the five walls are:
B B
B., .B, BB, B., and .B
In the third sample case, the nine walls are the five as in the second sample case and in addition the following four:
B B
B B B B
B., .B, BB, and BB
Submitted Solution:
```
result=0
mod=10**6 +3
n,C=map(int,input().split())
def BinCoefficient(n,k):
# since C(n, k) = C(n, n - k)
if(k > n - k):
k = n - k
# initialize result
res = 1
# Calculate value of
# [n * (n-1) *---* (n-k + 1)] / [k * (k-1) *----* 1]
for i in range(k):
res = res * (n - i) %mod
res = (res / (i + 1)) %mod
return res %mod
for i in range(1,n+1):
result=(BinCoefficient(i+C-1,C-1)+result)%mod
print(int(result%mod))
``` | instruction | 0 | 81,305 | 8 | 162,610 |
No | output | 1 | 81,305 | 8 | 162,611 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
Heidi the Cow is aghast: cracks in the northern Wall? Zombies gathering outside, forming groups, preparing their assault? This must not happen! Quickly, she fetches her HC2 (Handbook of Crazy Constructions) and looks for the right chapter:
How to build a wall:
1. Take a set of bricks.
2. Select one of the possible wall designs. Computing the number of possible designs is left as an exercise to the reader.
3. Place bricks on top of each other, according to the chosen design.
This seems easy enough. But Heidi is a Coding Cow, not a Constructing Cow. Her mind keeps coming back to point 2b. Despite the imminent danger of a zombie onslaught, she wonders just how many possible walls she could build with up to n bricks.
A wall is a set of wall segments as defined in the easy version. How many different walls can be constructed such that the wall consists of at least 1 and at most n bricks? Two walls are different if there exist a column c and a row r such that one wall has a brick in this spot, and the other does not.
Along with n, you will be given C, the width of the wall (as defined in the easy version). Return the number of different walls modulo 106 + 3.
Input
The first line contains two space-separated integers n and C, 1 ≤ n ≤ 500000, 1 ≤ C ≤ 200000.
Output
Print the number of different walls that Heidi could build, modulo 106 + 3.
Examples
Input
5 1
Output
5
Input
2 2
Output
5
Input
3 2
Output
9
Input
11 5
Output
4367
Input
37 63
Output
230574
Note
The number 106 + 3 is prime.
In the second sample case, the five walls are:
B B
B., .B, BB, B., and .B
In the third sample case, the nine walls are the five as in the second sample case and in addition the following four:
B B
B B B B
B., .B, BB, and BB
Submitted Solution:
```
n, m = map(int,input().split())
n, m = min(n,m), max(n,m)
f1 = 1
con = 10**10
const = 10**6 + 3
for i in range(m+1, n+m+1):
f1 *= i
f1 /= i-m
print(int(f1-1) % const)
``` | instruction | 0 | 81,306 | 8 | 162,612 |
No | output | 1 | 81,306 | 8 | 162,613 |
Provide a correct Python 3 solution for this coding contest problem.
There are N blocks, numbered 1, 2, \ldots, N. For each i (1 \leq i \leq N), Block i has a weight of w_i, a solidness of s_i and a value of v_i.
Taro has decided to build a tower by choosing some of the N blocks and stacking them vertically in some order. Here, the tower must satisfy the following condition:
* For each Block i contained in the tower, the sum of the weights of the blocks stacked above it is not greater than s_i.
Find the maximum possible sum of the values of the blocks contained in the tower.
Constraints
* All values in input are integers.
* 1 \leq N \leq 10^3
* 1 \leq w_i, s_i \leq 10^4
* 1 \leq v_i \leq 10^9
Input
Input is given from Standard Input in the following format:
N
w_1 s_1 v_1
w_2 s_2 v_2
:
w_N s_N v_N
Output
Print the maximum possible sum of the values of the blocks contained in the tower.
Examples
Input
3
2 2 20
2 1 30
3 1 40
Output
50
Input
4
1 2 10
3 1 10
2 4 10
1 6 10
Output
40
Input
5
1 10000 1000000000
1 10000 1000000000
1 10000 1000000000
1 10000 1000000000
1 10000 1000000000
Output
5000000000
Input
8
9 5 7
6 2 7
5 7 3
7 8 8
1 9 6
3 3 3
4 1 7
4 5 5
Output
22 | instruction | 0 | 81,506 | 8 | 163,012 |
"Correct Solution:
```
def resolve():
from functools import cmp_to_key
# aをbの上に配置するとき、W≤sa と W+wa≤sbを満たす必要: W≤min(sa,sb−wa)
# bをaの上に配置するとき、同様に: W≤min(sb,sa−wb)
def cmp(a, b):
va = min(a[1], b[1] - a[0])
vb = min(b[1], a[1] - b[0])
if (va == vb): return 0
return -1 if (va > vb) else 1
N = int(input())
# Block[w][s][v]
Block = [list(map(int, input().split())) for _ in range(N)]
Block.sort(key=cmp_to_key(cmp))
max_W = 2*(10**4+1)
dp = [[0]*(max_W+5) for _ in range(N+1)]
# dp[i][tot] := i番目までを使って、重さの総和がtotである場合の価値の総和の最大値
for i in range(N):
w, s, v = Block[i]
for tot in range(max_W):
dp[i+1][tot] = max(dp[i+1][tot], dp[i][tot])
if tot <= s:
dp[i + 1][tot+w] = max(dp[i + 1][tot+w], dp[i][tot] + v)
print(max(dp[N]))
if __name__ == "__main__":
resolve()
``` | output | 1 | 81,506 | 8 | 163,013 |
Provide a correct Python 3 solution for this coding contest problem.
There are N blocks, numbered 1, 2, \ldots, N. For each i (1 \leq i \leq N), Block i has a weight of w_i, a solidness of s_i and a value of v_i.
Taro has decided to build a tower by choosing some of the N blocks and stacking them vertically in some order. Here, the tower must satisfy the following condition:
* For each Block i contained in the tower, the sum of the weights of the blocks stacked above it is not greater than s_i.
Find the maximum possible sum of the values of the blocks contained in the tower.
Constraints
* All values in input are integers.
* 1 \leq N \leq 10^3
* 1 \leq w_i, s_i \leq 10^4
* 1 \leq v_i \leq 10^9
Input
Input is given from Standard Input in the following format:
N
w_1 s_1 v_1
w_2 s_2 v_2
:
w_N s_N v_N
Output
Print the maximum possible sum of the values of the blocks contained in the tower.
Examples
Input
3
2 2 20
2 1 30
3 1 40
Output
50
Input
4
1 2 10
3 1 10
2 4 10
1 6 10
Output
40
Input
5
1 10000 1000000000
1 10000 1000000000
1 10000 1000000000
1 10000 1000000000
1 10000 1000000000
Output
5000000000
Input
8
9 5 7
6 2 7
5 7 3
7 8 8
1 9 6
3 3 3
4 1 7
4 5 5
Output
22 | instruction | 0 | 81,507 | 8 | 163,014 |
"Correct Solution:
```
n = int(input())
wsv = [list(map(int,input().split())) for i in range(n)]
wsv.sort(key = lambda x:x[0]+x[1],reverse=True)
smx = max(list(zip(*wsv))[1])
dp = [[0 for i in range(smx+1)] for j in range(n+1)]
for i in range(1,n+1):
dp[i] = dp[i-1][:]
w,s,v = wsv[i-1]
dp[i][s] = max(dp[i-1][s],v)
for ss in range(smx+1)[::-1]:
sn = min(ss-w,s)
if sn >= 0 and dp[i-1][ss]:
dp[i][sn] = max(dp[i][sn],dp[i-1][sn],dp[i-1][ss]+v)
print(max(dp[-1]))
``` | output | 1 | 81,507 | 8 | 163,015 |
Provide a correct Python 3 solution for this coding contest problem.
There are N blocks, numbered 1, 2, \ldots, N. For each i (1 \leq i \leq N), Block i has a weight of w_i, a solidness of s_i and a value of v_i.
Taro has decided to build a tower by choosing some of the N blocks and stacking them vertically in some order. Here, the tower must satisfy the following condition:
* For each Block i contained in the tower, the sum of the weights of the blocks stacked above it is not greater than s_i.
Find the maximum possible sum of the values of the blocks contained in the tower.
Constraints
* All values in input are integers.
* 1 \leq N \leq 10^3
* 1 \leq w_i, s_i \leq 10^4
* 1 \leq v_i \leq 10^9
Input
Input is given from Standard Input in the following format:
N
w_1 s_1 v_1
w_2 s_2 v_2
:
w_N s_N v_N
Output
Print the maximum possible sum of the values of the blocks contained in the tower.
Examples
Input
3
2 2 20
2 1 30
3 1 40
Output
50
Input
4
1 2 10
3 1 10
2 4 10
1 6 10
Output
40
Input
5
1 10000 1000000000
1 10000 1000000000
1 10000 1000000000
1 10000 1000000000
1 10000 1000000000
Output
5000000000
Input
8
9 5 7
6 2 7
5 7 3
7 8 8
1 9 6
3 3 3
4 1 7
4 5 5
Output
22 | instruction | 0 | 81,508 | 8 | 163,016 |
"Correct Solution:
```
N = int(input())
P = [list(map(int, input().split())) for i in range(N)]
P.sort(key=lambda x: x[0]+x[1])
L = 10**5
dp = [0]*L
for w, s, v in P:
for i in range(s, -1, -1):
dp[i+w] = max(dp[i+w], dp[i] + v)
print(max(dp))
``` | output | 1 | 81,508 | 8 | 163,017 |
Provide a correct Python 3 solution for this coding contest problem.
There are N blocks, numbered 1, 2, \ldots, N. For each i (1 \leq i \leq N), Block i has a weight of w_i, a solidness of s_i and a value of v_i.
Taro has decided to build a tower by choosing some of the N blocks and stacking them vertically in some order. Here, the tower must satisfy the following condition:
* For each Block i contained in the tower, the sum of the weights of the blocks stacked above it is not greater than s_i.
Find the maximum possible sum of the values of the blocks contained in the tower.
Constraints
* All values in input are integers.
* 1 \leq N \leq 10^3
* 1 \leq w_i, s_i \leq 10^4
* 1 \leq v_i \leq 10^9
Input
Input is given from Standard Input in the following format:
N
w_1 s_1 v_1
w_2 s_2 v_2
:
w_N s_N v_N
Output
Print the maximum possible sum of the values of the blocks contained in the tower.
Examples
Input
3
2 2 20
2 1 30
3 1 40
Output
50
Input
4
1 2 10
3 1 10
2 4 10
1 6 10
Output
40
Input
5
1 10000 1000000000
1 10000 1000000000
1 10000 1000000000
1 10000 1000000000
1 10000 1000000000
Output
5000000000
Input
8
9 5 7
6 2 7
5 7 3
7 8 8
1 9 6
3 3 3
4 1 7
4 5 5
Output
22 | instruction | 0 | 81,509 | 8 | 163,018 |
"Correct Solution:
```
def read_int():
return int(input().strip())
def read_ints():
return list(map(int, input().strip().split(' ')))
def solve():
"""
assume s1 was bottom
s1-w0 > s0-w1 better solidness
s1+w1 > s0+w0
otherwise
s1+w1 < s0+w0
OPT[i][j] - maximum value up to i-th brick with weight j
OPT[i][j] = OPT[i-1][j-w[i]]+v[i] if we take i-th brick, 0 <= j-w[i] <= s[i]
OPT[i-1][j]
OPT[0][w[0]] = v[0], otherwise OPT[0][j] = 0
"""
N = read_int()
pairs = []
max_w = 0
max_s = 0
for _ in range(N):
w0, s0, v0 = read_ints()
max_w = max(max_w, w0)
max_s = max(max_s, s0)
pairs.append((s0+w0, w0, s0, v0))
MAX_WEIGHT = max_w+max_s+1
pairs.sort()
OPT = [
[0]*MAX_WEIGHT for _ in range(N)
]
OPT[0][pairs[0][1]] = pairs[0][3]
for i in range(1, N):
for j in range(MAX_WEIGHT):
OPT[i][j] = max(OPT[i][j], OPT[i-1][j])
if 0 <= j-pairs[i][1] <= pairs[i][2]:
OPT[i][j] = max(OPT[i][j], OPT[i-1][j-pairs[i][1]]+pairs[i][3])
return max(OPT[-1])
if __name__ == '__main__':
print(solve())
``` | output | 1 | 81,509 | 8 | 163,019 |
Provide a correct Python 3 solution for this coding contest problem.
There are N blocks, numbered 1, 2, \ldots, N. For each i (1 \leq i \leq N), Block i has a weight of w_i, a solidness of s_i and a value of v_i.
Taro has decided to build a tower by choosing some of the N blocks and stacking them vertically in some order. Here, the tower must satisfy the following condition:
* For each Block i contained in the tower, the sum of the weights of the blocks stacked above it is not greater than s_i.
Find the maximum possible sum of the values of the blocks contained in the tower.
Constraints
* All values in input are integers.
* 1 \leq N \leq 10^3
* 1 \leq w_i, s_i \leq 10^4
* 1 \leq v_i \leq 10^9
Input
Input is given from Standard Input in the following format:
N
w_1 s_1 v_1
w_2 s_2 v_2
:
w_N s_N v_N
Output
Print the maximum possible sum of the values of the blocks contained in the tower.
Examples
Input
3
2 2 20
2 1 30
3 1 40
Output
50
Input
4
1 2 10
3 1 10
2 4 10
1 6 10
Output
40
Input
5
1 10000 1000000000
1 10000 1000000000
1 10000 1000000000
1 10000 1000000000
1 10000 1000000000
Output
5000000000
Input
8
9 5 7
6 2 7
5 7 3
7 8 8
1 9 6
3 3 3
4 1 7
4 5 5
Output
22 | instruction | 0 | 81,510 | 8 | 163,020 |
"Correct Solution:
```
from functools import cmp_to_key
def cmp(a, b):
w1, s1, v1 = a
w2, s2, v2 = b
if min(s1, s2-w1)>min(s2, s1-w2):
return 1
else:
return -1
N = int(input())
dp = [[0]*10001 for _ in range(N)]
wsv = []
for _ in range(N):
w, s, v = map(int, input().split())
wsv.append((w, s, v))
wsv.sort(key = lambda x:-(x[0]+x[1]))
w, s, v = wsv[0]
dp[0][s] = v
for i in range(N-1):
w, s, v = wsv[i+1]
for j in range(10001):
if j>=w:
dp[i+1][min(s, j-w)] = max(dp[i][j]+v, dp[i+1][min(s, j-w)])
dp[i+1][j] = max(dp[i+1][j], dp[i][j])
dp[i+1][s] = max(dp[i+1][s], v)
print(max(dp[-1]))
``` | output | 1 | 81,510 | 8 | 163,021 |
Provide a correct Python 3 solution for this coding contest problem.
There are N blocks, numbered 1, 2, \ldots, N. For each i (1 \leq i \leq N), Block i has a weight of w_i, a solidness of s_i and a value of v_i.
Taro has decided to build a tower by choosing some of the N blocks and stacking them vertically in some order. Here, the tower must satisfy the following condition:
* For each Block i contained in the tower, the sum of the weights of the blocks stacked above it is not greater than s_i.
Find the maximum possible sum of the values of the blocks contained in the tower.
Constraints
* All values in input are integers.
* 1 \leq N \leq 10^3
* 1 \leq w_i, s_i \leq 10^4
* 1 \leq v_i \leq 10^9
Input
Input is given from Standard Input in the following format:
N
w_1 s_1 v_1
w_2 s_2 v_2
:
w_N s_N v_N
Output
Print the maximum possible sum of the values of the blocks contained in the tower.
Examples
Input
3
2 2 20
2 1 30
3 1 40
Output
50
Input
4
1 2 10
3 1 10
2 4 10
1 6 10
Output
40
Input
5
1 10000 1000000000
1 10000 1000000000
1 10000 1000000000
1 10000 1000000000
1 10000 1000000000
Output
5000000000
Input
8
9 5 7
6 2 7
5 7 3
7 8 8
1 9 6
3 3 3
4 1 7
4 5 5
Output
22 | instruction | 0 | 81,511 | 8 | 163,022 |
"Correct Solution:
```
# from https://ikatakos.com/pot/programming_algorithm/contest_history/atcoder/2019/0106_educational_dp_4
import sys
n=int(input())
blocks=[]
for line in sys.stdin.readlines():
w,s,v=map(int,line.split())
blocks.append((w+s,w,s,v))
blocks.sort()
dp=[-1]*20001
dp[0]=0
for _,w,s,v in blocks:
for i in range(s,-1,-1):
if dp[i]==-1:
continue
dp[i+w]=max(dp[i+w],dp[i]+v)
print(max(dp))
``` | output | 1 | 81,511 | 8 | 163,023 |
Provide a correct Python 3 solution for this coding contest problem.
There are N blocks, numbered 1, 2, \ldots, N. For each i (1 \leq i \leq N), Block i has a weight of w_i, a solidness of s_i and a value of v_i.
Taro has decided to build a tower by choosing some of the N blocks and stacking them vertically in some order. Here, the tower must satisfy the following condition:
* For each Block i contained in the tower, the sum of the weights of the blocks stacked above it is not greater than s_i.
Find the maximum possible sum of the values of the blocks contained in the tower.
Constraints
* All values in input are integers.
* 1 \leq N \leq 10^3
* 1 \leq w_i, s_i \leq 10^4
* 1 \leq v_i \leq 10^9
Input
Input is given from Standard Input in the following format:
N
w_1 s_1 v_1
w_2 s_2 v_2
:
w_N s_N v_N
Output
Print the maximum possible sum of the values of the blocks contained in the tower.
Examples
Input
3
2 2 20
2 1 30
3 1 40
Output
50
Input
4
1 2 10
3 1 10
2 4 10
1 6 10
Output
40
Input
5
1 10000 1000000000
1 10000 1000000000
1 10000 1000000000
1 10000 1000000000
1 10000 1000000000
Output
5000000000
Input
8
9 5 7
6 2 7
5 7 3
7 8 8
1 9 6
3 3 3
4 1 7
4 5 5
Output
22 | instruction | 0 | 81,512 | 8 | 163,024 |
"Correct Solution:
```
def I(): return int(input())
def MI(): return map(int, input().split())
def LI(): return list(map(int, input().split()))
def main():
mod=10**9+7
"""
dp[i][j]はi番目までで，重さ合計がjとなるときの価値の最大値にしたい．
s<10**4 なので，jは10**4 + 10**4まで．
ただし，上から積む時に実際には優先度がつくので，重りを適切な基準でソートすべき．
現状，重さがXで，a番目とj番目を使うとして，
「X,a,bの順番ならおけるけど，X,b,aの順だとおけない」
という状況を考える．
この時，S_j>=X+w_i かつ，s_i<X+w_j なので．
S_j - w_i >= X > s_i - w_j である．
Xを消去して移項すると，
s_j+w_j > s_i+w_i
これを基準にソートですね．
"""
N=I()
wsv=[]
for i in range(N):
w,s,v=MI()
wsv.append([w,s,v])
wsv.sort(key=lambda x:(x[0]+x[1]))
N2=2*(10**4) +1
dp=[[0]*N2 for _ in range(N+1)]
for i in range(N):
w,s,v=wsv[i]
for j in range(N2):
dp[i+1][j]=max(dp[i][j],dp[i+1][j])
if s>=j and j+w<=(N2-1):
dp[i+1][j+w]=max(dp[i+1][j+w],dp[i][j]+v)
print(max(dp[-1]))
main()
``` | output | 1 | 81,512 | 8 | 163,025 |
Provide a correct Python 3 solution for this coding contest problem.
There are N blocks, numbered 1, 2, \ldots, N. For each i (1 \leq i \leq N), Block i has a weight of w_i, a solidness of s_i and a value of v_i.
Taro has decided to build a tower by choosing some of the N blocks and stacking them vertically in some order. Here, the tower must satisfy the following condition:
* For each Block i contained in the tower, the sum of the weights of the blocks stacked above it is not greater than s_i.
Find the maximum possible sum of the values of the blocks contained in the tower.
Constraints
* All values in input are integers.
* 1 \leq N \leq 10^3
* 1 \leq w_i, s_i \leq 10^4
* 1 \leq v_i \leq 10^9
Input
Input is given from Standard Input in the following format:
N
w_1 s_1 v_1
w_2 s_2 v_2
:
w_N s_N v_N
Output
Print the maximum possible sum of the values of the blocks contained in the tower.
Examples
Input
3
2 2 20
2 1 30
3 1 40
Output
50
Input
4
1 2 10
3 1 10
2 4 10
1 6 10
Output
40
Input
5
1 10000 1000000000
1 10000 1000000000
1 10000 1000000000
1 10000 1000000000
1 10000 1000000000
Output
5000000000
Input
8
9 5 7
6 2 7
5 7 3
7 8 8
1 9 6
3 3 3
4 1 7
4 5 5
Output
22 | instruction | 0 | 81,513 | 8 | 163,026 |
"Correct Solution:
```
import sys
input = sys.stdin.readline
def solve():
N = int(input())
items = [tuple(map(int, input().split())) for _ in range(N)]
capW = max([w+s for w, s, v in items])
items.sort(key=lambda x: x[0]+x[1])
def knapsack01(items, capW):
dp = [0] * (capW+1)
for wi, si, vi in items:
for w in reversed(range(wi, si+wi+1)):
v0 = dp[w-wi] + vi
if v0 > dp[w]:
dp[w] = v0
return max(dp)
ans = knapsack01(items, capW)
print(ans)
solve()
``` | output | 1 | 81,513 | 8 | 163,027 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
There are N blocks, numbered 1, 2, \ldots, N. For each i (1 \leq i \leq N), Block i has a weight of w_i, a solidness of s_i and a value of v_i.
Taro has decided to build a tower by choosing some of the N blocks and stacking them vertically in some order. Here, the tower must satisfy the following condition:
* For each Block i contained in the tower, the sum of the weights of the blocks stacked above it is not greater than s_i.
Find the maximum possible sum of the values of the blocks contained in the tower.
Constraints
* All values in input are integers.
* 1 \leq N \leq 10^3
* 1 \leq w_i, s_i \leq 10^4
* 1 \leq v_i \leq 10^9
Input
Input is given from Standard Input in the following format:
N
w_1 s_1 v_1
w_2 s_2 v_2
:
w_N s_N v_N
Output
Print the maximum possible sum of the values of the blocks contained in the tower.
Examples
Input
3
2 2 20
2 1 30
3 1 40
Output
50
Input
4
1 2 10
3 1 10
2 4 10
1 6 10
Output
40
Input
5
1 10000 1000000000
1 10000 1000000000
1 10000 1000000000
1 10000 1000000000
1 10000 1000000000
Output
5000000000
Input
8
9 5 7
6 2 7
5 7 3
7 8 8
1 9 6
3 3 3
4 1 7
4 5 5
Output
22
Submitted Solution:
```
I = [int(_) for _ in open(0).read().split()]
N = I[0]
W, S, V = I[1::3], I[2::3], I[3::3]
dp = [-float('inf')] * (2 * 10**4 + 5)
dp[0] = 0
#dp[重さの総和]=その重さの総和になる最大価値
for s, w, v in sorted(zip(S, W, V), key=lambda swv: swv[0] + swv[1]):
for wbefore in range(s, -1, -1):
dp[wbefore + w] = max(dp[wbefore + w], dp[wbefore] + v)
print(max(dp))
``` | instruction | 0 | 81,514 | 8 | 163,028 |
Yes | output | 1 | 81,514 | 8 | 163,029 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
There are N blocks, numbered 1, 2, \ldots, N. For each i (1 \leq i \leq N), Block i has a weight of w_i, a solidness of s_i and a value of v_i.
Taro has decided to build a tower by choosing some of the N blocks and stacking them vertically in some order. Here, the tower must satisfy the following condition:
* For each Block i contained in the tower, the sum of the weights of the blocks stacked above it is not greater than s_i.
Find the maximum possible sum of the values of the blocks contained in the tower.
Constraints
* All values in input are integers.
* 1 \leq N \leq 10^3
* 1 \leq w_i, s_i \leq 10^4
* 1 \leq v_i \leq 10^9
Input
Input is given from Standard Input in the following format:
N
w_1 s_1 v_1
w_2 s_2 v_2
:
w_N s_N v_N
Output
Print the maximum possible sum of the values of the blocks contained in the tower.
Examples
Input
3
2 2 20
2 1 30
3 1 40
Output
50
Input
4
1 2 10
3 1 10
2 4 10
1 6 10
Output
40
Input
5
1 10000 1000000000
1 10000 1000000000
1 10000 1000000000
1 10000 1000000000
1 10000 1000000000
Output
5000000000
Input
8
9 5 7
6 2 7
5 7 3
7 8 8
1 9 6
3 3 3
4 1 7
4 5 5
Output
22
Submitted Solution:
```
N, = map(int, input().split())
Xs = []
for i in range(N):
X, Y, Z = map(int, input().split())
Xs.append((X,Y,Z,i))
Xs.sort(key=lambda x : x[0]+x[1])
dp = [0]*(2*(10**4)+1)
for x,y,z,i in Xs:
# print(i+1,x,y,z)
for i in range(y+1):
i = y-i
dp[i+x] = max(dp[i+x], dp[i]+z)
# print(dp[:10])
print(max(dp))
``` | instruction | 0 | 81,515 | 8 | 163,030 |
Yes | output | 1 | 81,515 | 8 | 163,031 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
There are N blocks, numbered 1, 2, \ldots, N. For each i (1 \leq i \leq N), Block i has a weight of w_i, a solidness of s_i and a value of v_i.
Taro has decided to build a tower by choosing some of the N blocks and stacking them vertically in some order. Here, the tower must satisfy the following condition:
* For each Block i contained in the tower, the sum of the weights of the blocks stacked above it is not greater than s_i.
Find the maximum possible sum of the values of the blocks contained in the tower.
Constraints
* All values in input are integers.
* 1 \leq N \leq 10^3
* 1 \leq w_i, s_i \leq 10^4
* 1 \leq v_i \leq 10^9
Input
Input is given from Standard Input in the following format:
N
w_1 s_1 v_1
w_2 s_2 v_2
:
w_N s_N v_N
Output
Print the maximum possible sum of the values of the blocks contained in the tower.
Examples
Input
3
2 2 20
2 1 30
3 1 40
Output
50
Input
4
1 2 10
3 1 10
2 4 10
1 6 10
Output
40
Input
5
1 10000 1000000000
1 10000 1000000000
1 10000 1000000000
1 10000 1000000000
1 10000 1000000000
Output
5000000000
Input
8
9 5 7
6 2 7
5 7 3
7 8 8
1 9 6
3 3 3
4 1 7
4 5 5
Output
22
Submitted Solution:
```
def main():
import sys
input = sys.stdin.readline
N = int(input())
wsv = []
for _ in range(N):
w, s, v = map(int, input().split())
wsv.append((w, s, v))
wsv.sort(key=lambda x: x[0] + x[1])
inf = 1000000007
dp = [[-inf] * 20001 for _ in range(N+1)]
dp[0][0] = 0
for i in range(N):
w, s, v = wsv[i]
for j in range(20001):
if dp[i][j] != -inf:
dp[i+1][j] = max(dp[i+1][j], dp[i][j])
if j <= s:
dp[i+1][j+w] = max(dp[i+1][j+w], dp[i][j] + v)
print(max(dp[-1]))
if __name__ == '__main__':
main()
``` | instruction | 0 | 81,516 | 8 | 163,032 |
Yes | output | 1 | 81,516 | 8 | 163,033 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
There are N blocks, numbered 1, 2, \ldots, N. For each i (1 \leq i \leq N), Block i has a weight of w_i, a solidness of s_i and a value of v_i.
Taro has decided to build a tower by choosing some of the N blocks and stacking them vertically in some order. Here, the tower must satisfy the following condition:
* For each Block i contained in the tower, the sum of the weights of the blocks stacked above it is not greater than s_i.
Find the maximum possible sum of the values of the blocks contained in the tower.
Constraints
* All values in input are integers.
* 1 \leq N \leq 10^3
* 1 \leq w_i, s_i \leq 10^4
* 1 \leq v_i \leq 10^9
Input
Input is given from Standard Input in the following format:
N
w_1 s_1 v_1
w_2 s_2 v_2
:
w_N s_N v_N
Output
Print the maximum possible sum of the values of the blocks contained in the tower.
Examples
Input
3
2 2 20
2 1 30
3 1 40
Output
50
Input
4
1 2 10
3 1 10
2 4 10
1 6 10
Output
40
Input
5
1 10000 1000000000
1 10000 1000000000
1 10000 1000000000
1 10000 1000000000
1 10000 1000000000
Output
5000000000
Input
8
9 5 7
6 2 7
5 7 3
7 8 8
1 9 6
3 3 3
4 1 7
4 5 5
Output
22
Submitted Solution:
```
import sys
read = sys.stdin.buffer.read
readline = sys.stdin.buffer.readline
readlines = sys.stdin.buffer.readlines
n = int(readline())
wsv = [list(map(int,readline().split())) for _ in range(n)]
wsv.sort(key=lambda x:x[0]+x[1])
dp = [[0] * (2*10**4+1) for _ in range(n+1)]
for i in range(n):
wi,si,vi = wsv[i]
for j in range(1,2*10**4+1):
if(j < wi):
dp[i+1][j] = max(dp[i+1][j-1],dp[i][j])
elif(j <= wi+si):
dp[i+1][j] = max(dp[i+1][j-1],dp[i][j],dp[i][j-wi]+vi)
else:
dp[i+1][j] = max(dp[i+1][j-1],dp[i][j])
print(dp[-1][-1])
``` | instruction | 0 | 81,517 | 8 | 163,034 |
Yes | output | 1 | 81,517 | 8 | 163,035 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
There are N blocks, numbered 1, 2, \ldots, N. For each i (1 \leq i \leq N), Block i has a weight of w_i, a solidness of s_i and a value of v_i.
Taro has decided to build a tower by choosing some of the N blocks and stacking them vertically in some order. Here, the tower must satisfy the following condition:
* For each Block i contained in the tower, the sum of the weights of the blocks stacked above it is not greater than s_i.
Find the maximum possible sum of the values of the blocks contained in the tower.
Constraints
* All values in input are integers.
* 1 \leq N \leq 10^3
* 1 \leq w_i, s_i \leq 10^4
* 1 \leq v_i \leq 10^9
Input
Input is given from Standard Input in the following format:
N
w_1 s_1 v_1
w_2 s_2 v_2
:
w_N s_N v_N
Output
Print the maximum possible sum of the values of the blocks contained in the tower.
Examples
Input
3
2 2 20
2 1 30
3 1 40
Output
50
Input
4
1 2 10
3 1 10
2 4 10
1 6 10
Output
40
Input
5
1 10000 1000000000
1 10000 1000000000
1 10000 1000000000
1 10000 1000000000
1 10000 1000000000
Output
5000000000
Input
8
9 5 7
6 2 7
5 7 3
7 8 8
1 9 6
3 3 3
4 1 7
4 5 5
Output
22
Submitted Solution:
```
from functools import cmp_to_key
def cmp(a, b):
w1, s1, v1 = a
w2, s2, v2 = b
if min(s1, s2-w1)>min(s2, s1-w2):
return 1
else:
return -1
N = int(input())
dp = [[0]*10001 for _ in range(N)]
wsv = []
for _ in range(N):
w, s, v = map(int, input().split())
wsv.append((w, s, v))
wsv.sort(key = lambda x:x[0]+x[1])
w, s, v = wsv[0]
dp[0][s] = v
for i in range(N-1):
w, s, v = wsv[i+1]
for j in range(10001):
if j>=w:
dp[i+1][min(s, j-w)] = max(dp[i][j]+v, dp[i+1][min(s, j-w)])
dp[i+1][j] = max(dp[i+1][j], dp[i][j])
print(max(dp[-1]))
``` | instruction | 0 | 81,518 | 8 | 163,036 |
No | output | 1 | 81,518 | 8 | 163,037 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
There are N blocks, numbered 1, 2, \ldots, N. For each i (1 \leq i \leq N), Block i has a weight of w_i, a solidness of s_i and a value of v_i.
Taro has decided to build a tower by choosing some of the N blocks and stacking them vertically in some order. Here, the tower must satisfy the following condition:
* For each Block i contained in the tower, the sum of the weights of the blocks stacked above it is not greater than s_i.
Find the maximum possible sum of the values of the blocks contained in the tower.
Constraints
* All values in input are integers.
* 1 \leq N \leq 10^3
* 1 \leq w_i, s_i \leq 10^4
* 1 \leq v_i \leq 10^9
Input
Input is given from Standard Input in the following format:
N
w_1 s_1 v_1
w_2 s_2 v_2
:
w_N s_N v_N
Output
Print the maximum possible sum of the values of the blocks contained in the tower.
Examples
Input
3
2 2 20
2 1 30
3 1 40
Output
50
Input
4
1 2 10
3 1 10
2 4 10
1 6 10
Output
40
Input
5
1 10000 1000000000
1 10000 1000000000
1 10000 1000000000
1 10000 1000000000
1 10000 1000000000
Output
5000000000
Input
8
9 5 7
6 2 7
5 7 3
7 8 8
1 9 6
3 3 3
4 1 7
4 5 5
Output
22
Submitted Solution:
```
def resolve():
from functools import cmp_to_key
# aをbの上に配置するとき、W≤sa と W+wa≤sbを満たす必要: W≤min(sa,sb−wa)
# bをaの上に配置するとき、同様に: W≤min(sb,sa−wb)
def cmp(a, b):
va = min(a[1], b[1] - a[0])
vb = min(b[1], a[1] - b[0])
if (va == vb): return 0
return -1 if (va > vb) else 1
N = int(input())
# Block[w][s][v]
Block = [list(map(int, input().split())) for _ in range(N)]
Block.sort(key=cmp_to_key(cmp))
max_W = 10**4+1
dp = [[0]*(2*max_W+5) for _ in range(N+1)]
# dp[i][tot] := i番目までを使って、重さの総和がtotである場合の価値の総和の最大値
for i in range(N):
for tot in range(max_W+1):
dp[i+1][tot] = max(dp[i+1][tot], dp[i][tot])
if tot <= Block[i][1]:
dp[i + 1][tot+Block[i][0]] = max(dp[i + 1][tot+Block[i][0]], dp[i][tot] + Block[i][2])
print(max(dp[N]))
if __name__ == "__main__":
resolve()
``` | instruction | 0 | 81,519 | 8 | 163,038 |
No | output | 1 | 81,519 | 8 | 163,039 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
There are N blocks, numbered 1, 2, \ldots, N. For each i (1 \leq i \leq N), Block i has a weight of w_i, a solidness of s_i and a value of v_i.
Taro has decided to build a tower by choosing some of the N blocks and stacking them vertically in some order. Here, the tower must satisfy the following condition:
* For each Block i contained in the tower, the sum of the weights of the blocks stacked above it is not greater than s_i.
Find the maximum possible sum of the values of the blocks contained in the tower.
Constraints
* All values in input are integers.
* 1 \leq N \leq 10^3
* 1 \leq w_i, s_i \leq 10^4
* 1 \leq v_i \leq 10^9
Input
Input is given from Standard Input in the following format:
N
w_1 s_1 v_1
w_2 s_2 v_2
:
w_N s_N v_N
Output
Print the maximum possible sum of the values of the blocks contained in the tower.
Examples
Input
3
2 2 20
2 1 30
3 1 40
Output
50
Input
4
1 2 10
3 1 10
2 4 10
1 6 10
Output
40
Input
5
1 10000 1000000000
1 10000 1000000000
1 10000 1000000000
1 10000 1000000000
1 10000 1000000000
Output
5000000000
Input
8
9 5 7
6 2 7
5 7 3
7 8 8
1 9 6
3 3 3
4 1 7
4 5 5
Output
22
Submitted Solution:
```
import sys
n = int(input())
blocks = []
for line in sys.stdin.readlines():
w, s, v = map(int, line.split())
blocks.append((w + s, w, s, v))
blocks.sort()
dp = [-1] * 20001
dp[0] = 0
for _, w, s, v in blocks:
for i in range(min(s, 20000 - w), -1, -1):
dp[i + w] = max(dp[i + w], dp[i] + v)
print(max(dp))
``` | instruction | 0 | 81,520 | 8 | 163,040 |
No | output | 1 | 81,520 | 8 | 163,041 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
There are N blocks, numbered 1, 2, \ldots, N. For each i (1 \leq i \leq N), Block i has a weight of w_i, a solidness of s_i and a value of v_i.
Taro has decided to build a tower by choosing some of the N blocks and stacking them vertically in some order. Here, the tower must satisfy the following condition:
* For each Block i contained in the tower, the sum of the weights of the blocks stacked above it is not greater than s_i.
Find the maximum possible sum of the values of the blocks contained in the tower.
Constraints
* All values in input are integers.
* 1 \leq N \leq 10^3
* 1 \leq w_i, s_i \leq 10^4
* 1 \leq v_i \leq 10^9
Input
Input is given from Standard Input in the following format:
N
w_1 s_1 v_1
w_2 s_2 v_2
:
w_N s_N v_N
Output
Print the maximum possible sum of the values of the blocks contained in the tower.
Examples
Input
3
2 2 20
2 1 30
3 1 40
Output
50
Input
4
1 2 10
3 1 10
2 4 10
1 6 10
Output
40
Input
5
1 10000 1000000000
1 10000 1000000000
1 10000 1000000000
1 10000 1000000000
1 10000 1000000000
Output
5000000000
Input
8
9 5 7
6 2 7
5 7 3
7 8 8
1 9 6
3 3 3
4 1 7
4 5 5
Output
22
Submitted Solution:
```
#https://ikatakos.com/pot/programming_algorithm/contest_history/atcoder/2019/0106_educational_dp_4
def I(): return int(input())
def MI(): return map(int, input().split())
def LI(): return list(map(int, input().split()))
def main():
mod=10**9+7
"""
dp[i][j]はi番目までで，重さ合計がjとなるときの価値の最大値にしたい．
s<10**4 なので，jもそこまで．
ただし，上から積む時に実際には優先度がつくので，重りを適切な基準でソートすべき．
現状，重さがXで，a番目とj番目を使うとして，
「X,a,bの順番ならおけるけど，X,b,aの順だとおけない」
という状況を考える．
この時，S_j>=X+w_i かつ，s_i<X+w_j なので．
S_j - w_i >= X > s_i - w_j である．
Xを消去して移項すると，
s_j+w_j > s_i+w_i
これを基準にソートですね．
"""
N=I()
wsv=[]
for i in range(N):
w,s,v=MI()
wsv.append([w,s,v])
wsv.sort(key=lambda x:(x[0]+x[1]))
dp=[[0]*(10**4+1) for _ in range(N+1)]
for i in range(N):
w,s,v=wsv[i]
for j in range(10**4+1):
dp[i+1][j]=max(dp[i][j],dp[i+1][j])
if s>=j and j+w<=(10**4):
dp[i+1][j+w]=max(dp[i+1][j+w],dp[i][j]+v)
print(max(dp[-1]))
main()
``` | instruction | 0 | 81,521 | 8 | 163,042 |
No | output | 1 | 81,521 | 8 | 163,043 |
Provide a correct Python 3 solution for this coding contest problem.
Summer vacation ended at last and the second semester has begun. You, a Kyoto University student, came to university and heard a rumor that somebody will barricade the entrance of your classroom. The barricade will be built just before the start of the A-th class and removed by Kyoto University students just before the start of the B-th class. All the classes conducted when the barricade is blocking the entrance will be cancelled and you will not be able to attend them. Today you take N classes and class i is conducted in the t_i-th period. You take at most one class in each period. Find the number of classes you can attend.
Constraints
* 1 \leq N \leq 1000
* 1 \leq A < B \leq 10^9
* 1 \leq t_i \leq 10^9
* All t_i values are distinct.
Input
N, A and B are given on the first line and t_i is given on the (i+1)-th line.
N A B
t1
:
tN
Output
Print the number of classes you can attend.
Examples
Input
5 5 9
4
3
6
9
1
Output
4
Input
5 4 9
5
6
7
8
9
Output
1
Input
4 3 6
9
6
8
1
Output
4
Input
2 1 2
1
2
Output
1 | instruction | 0 | 81,586 | 8 | 163,172 |
"Correct Solution:
```
N, A, B = map(int, input().split())
T = [int(input()) for _ in range(N)]
ans = 0
for t in T:
if not (A <= t < B):
ans += 1
print(ans)
``` | output | 1 | 81,586 | 8 | 163,173 |
Provide a correct Python 3 solution for this coding contest problem.
Summer vacation ended at last and the second semester has begun. You, a Kyoto University student, came to university and heard a rumor that somebody will barricade the entrance of your classroom. The barricade will be built just before the start of the A-th class and removed by Kyoto University students just before the start of the B-th class. All the classes conducted when the barricade is blocking the entrance will be cancelled and you will not be able to attend them. Today you take N classes and class i is conducted in the t_i-th period. You take at most one class in each period. Find the number of classes you can attend.
Constraints
* 1 \leq N \leq 1000
* 1 \leq A < B \leq 10^9
* 1 \leq t_i \leq 10^9
* All t_i values are distinct.
Input
N, A and B are given on the first line and t_i is given on the (i+1)-th line.
N A B
t1
:
tN
Output
Print the number of classes you can attend.
Examples
Input
5 5 9
4
3
6
9
1
Output
4
Input
5 4 9
5
6
7
8
9
Output
1
Input
4 3 6
9
6
8
1
Output
4
Input
2 1 2
1
2
Output
1 | instruction | 0 | 81,587 | 8 | 163,174 |
"Correct Solution:
```
import bisect
n,a,b=map(int,input().split())
t=set([])
for i in range(n):
t.add(int(input()))
t=list(t)
t.sort()
ai=bisect.bisect_left(t,a)
bi=bisect.bisect_left(t,b)
print(len(t)-(bi-ai))
``` | output | 1 | 81,587 | 8 | 163,175 |
Provide a correct Python 3 solution for this coding contest problem.
Summer vacation ended at last and the second semester has begun. You, a Kyoto University student, came to university and heard a rumor that somebody will barricade the entrance of your classroom. The barricade will be built just before the start of the A-th class and removed by Kyoto University students just before the start of the B-th class. All the classes conducted when the barricade is blocking the entrance will be cancelled and you will not be able to attend them. Today you take N classes and class i is conducted in the t_i-th period. You take at most one class in each period. Find the number of classes you can attend.
Constraints
* 1 \leq N \leq 1000
* 1 \leq A < B \leq 10^9
* 1 \leq t_i \leq 10^9
* All t_i values are distinct.
Input
N, A and B are given on the first line and t_i is given on the (i+1)-th line.
N A B
t1
:
tN
Output
Print the number of classes you can attend.
Examples
Input
5 5 9
4
3
6
9
1
Output
4
Input
5 4 9
5
6
7
8
9
Output
1
Input
4 3 6
9
6
8
1
Output
4
Input
2 1 2
1
2
Output
1 | instruction | 0 | 81,588 | 8 | 163,176 |
"Correct Solution:
```
import bisect
N, A, B = map(int, input().split())
T = sorted([int(input()) for _ in range(N)])
l = bisect.bisect_left(T, A)
r = bisect.bisect_left(T, B)
print(N-(r-l))
``` | output | 1 | 81,588 | 8 | 163,177 |
Provide a correct Python 3 solution for this coding contest problem.
Summer vacation ended at last and the second semester has begun. You, a Kyoto University student, came to university and heard a rumor that somebody will barricade the entrance of your classroom. The barricade will be built just before the start of the A-th class and removed by Kyoto University students just before the start of the B-th class. All the classes conducted when the barricade is blocking the entrance will be cancelled and you will not be able to attend them. Today you take N classes and class i is conducted in the t_i-th period. You take at most one class in each period. Find the number of classes you can attend.
Constraints
* 1 \leq N \leq 1000
* 1 \leq A < B \leq 10^9
* 1 \leq t_i \leq 10^9
* All t_i values are distinct.
Input
N, A and B are given on the first line and t_i is given on the (i+1)-th line.
N A B
t1
:
tN
Output
Print the number of classes you can attend.
Examples
Input
5 5 9
4
3
6
9
1
Output
4
Input
5 4 9
5
6
7
8
9
Output
1
Input
4 3 6
9
6
8
1
Output
4
Input
2 1 2
1
2
Output
1 | instruction | 0 | 81,589 | 8 | 163,178 |
"Correct Solution:
```
N, A, B = [int(x) for x in input().split()]
t = [int(input()) for i in range(N)]
SUM = len([x for x in t if (x < A) or (x >= B)])
print(SUM)
``` | output | 1 | 81,589 | 8 | 163,179 |
Provide a correct Python 3 solution for this coding contest problem.
Summer vacation ended at last and the second semester has begun. You, a Kyoto University student, came to university and heard a rumor that somebody will barricade the entrance of your classroom. The barricade will be built just before the start of the A-th class and removed by Kyoto University students just before the start of the B-th class. All the classes conducted when the barricade is blocking the entrance will be cancelled and you will not be able to attend them. Today you take N classes and class i is conducted in the t_i-th period. You take at most one class in each period. Find the number of classes you can attend.
Constraints
* 1 \leq N \leq 1000
* 1 \leq A < B \leq 10^9
* 1 \leq t_i \leq 10^9
* All t_i values are distinct.
Input
N, A and B are given on the first line and t_i is given on the (i+1)-th line.
N A B
t1
:
tN
Output
Print the number of classes you can attend.
Examples
Input
5 5 9
4
3
6
9
1
Output
4
Input
5 4 9
5
6
7
8
9
Output
1
Input
4 3 6
9
6
8
1
Output
4
Input
2 1 2
1
2
Output
1 | instruction | 0 | 81,590 | 8 | 163,180 |
"Correct Solution:
```
N,A,B = (int(i) for i in input().split())
a = [int(input()) for i in range(N)]
j=0
for i in range(N):
if a[i]<A:
j += 1
elif a[i]>=B:
j += 1
print(j)
``` | output | 1 | 81,590 | 8 | 163,181 |
Provide a correct Python 3 solution for this coding contest problem.
Summer vacation ended at last and the second semester has begun. You, a Kyoto University student, came to university and heard a rumor that somebody will barricade the entrance of your classroom. The barricade will be built just before the start of the A-th class and removed by Kyoto University students just before the start of the B-th class. All the classes conducted when the barricade is blocking the entrance will be cancelled and you will not be able to attend them. Today you take N classes and class i is conducted in the t_i-th period. You take at most one class in each period. Find the number of classes you can attend.
Constraints
* 1 \leq N \leq 1000
* 1 \leq A < B \leq 10^9
* 1 \leq t_i \leq 10^9
* All t_i values are distinct.
Input
N, A and B are given on the first line and t_i is given on the (i+1)-th line.
N A B
t1
:
tN
Output
Print the number of classes you can attend.
Examples
Input
5 5 9
4
3
6
9
1
Output
4
Input
5 4 9
5
6
7
8
9
Output
1
Input
4 3 6
9
6
8
1
Output
4
Input
2 1 2
1
2
Output
1 | instruction | 0 | 81,591 | 8 | 163,182 |
"Correct Solution:
```
n,a,b=map(int,input().split())
ans=n
for i in range(n):
t=int(input())
if a<=t and t<b:
ans-=1
print(ans)
``` | output | 1 | 81,591 | 8 | 163,183 |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.