message stringlengths 2 48.6k | message_type stringclasses 2 values | message_id int64 0 1 | conversation_id int64 318 108k | cluster float64 8 8 | __index_level_0__ int64 636 217k |
|---|---|---|---|---|---|
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
After too much playing on paper, Iahub has switched to computer games. The game he plays is called "Block Towers". It is played in a rectangular grid with n rows and m columns (it contains n × m cells). The goal of the game is to build your own city. Some cells in the grid are big holes, where Iahub can't build any building. The rest of cells are empty. In some empty cell Iahub can build exactly one tower of two following types:
1. Blue towers. Each has population limit equal to 100.
2. Red towers. Each has population limit equal to 200. However, it can be built in some cell only if in that moment at least one of the neighbouring cells has a Blue Tower. Two cells are neighbours is they share a side.
Iahub is also allowed to destroy a building from any cell. He can do this operation as much as he wants. After destroying a building, the other buildings are not influenced, and the destroyed cell becomes empty (so Iahub can build a tower in this cell if needed, see the second example for such a case).
Iahub can convince as many population as he wants to come into his city. So he needs to configure his city to allow maximum population possible. Therefore he should find a sequence of operations that builds the city in an optimal way, so that total population limit is as large as possible.
He says he's the best at this game, but he doesn't have the optimal solution. Write a program that calculates the optimal one, to show him that he's not as good as he thinks.
Input
The first line of the input contains two integers n and m (1 ≤ n, m ≤ 500). Each of the next n lines contains m characters, describing the grid. The j-th character in the i-th line is '.' if you're allowed to build at the cell with coordinates (i, j) a tower (empty cell) or '#' if there is a big hole there.
Output
Print an integer k in the first line (0 ≤ k ≤ 106) — the number of operations Iahub should perform to obtain optimal result.
Each of the following k lines must contain a single operation in the following format:
1. «B x y» (1 ≤ x ≤ n, 1 ≤ y ≤ m) — building a blue tower at the cell (x, y);
2. «R x y» (1 ≤ x ≤ n, 1 ≤ y ≤ m) — building a red tower at the cell (x, y);
3. «D x y» (1 ≤ x ≤ n, 1 ≤ y ≤ m) — destroying a tower at the cell (x, y).
If there are multiple solutions you can output any of them. Note, that you shouldn't minimize the number of operations.
Examples
Input
2 3
..#
.#.
Output
4
B 1 1
R 1 2
R 2 1
B 2 3
Input
1 3
...
Output
5
B 1 1
B 1 2
R 1 3
D 1 2
R 1 2
Submitted Solution:
```
n, m = map(int, input().split())
s = [input() for i in range(n)]
d = [[-1 if s[i][j] == '.' else -2 for j in range(m)] for i in range(n)]
db = [[-1, 0], [1, 0], [0, -1], [0, 1]]
r, rp = -1, [0,0]
def solve(i, j, c):
if i < 0 or n <= i or j < 0 or m <= j:
return
if d[i][j] != -1:
return
d[i][j] = c
global r, rp
if r < c:
r = c
rp = [[i, j]]
elif r == c:
rp.append([i, j])
for u in db:
solve(i+u[0], j+u[1], c+1)
def solp(i, j, c):
if i < 0 or n <= i or j < 0 or m <= j:
return
if c <= 0 or d[i][j] != c:
return
print('D', i+1, j+1)
print('R', i+1, j+1)
for u in db:
solp(i+u[0], j+u[1], c-1)
k = 0
for i in range(n):
k += d[i].count(-1)
k *= 3
rb = []
for i in range(n):
for j in range(m):
if d[i][j] == -1:
k -= 2
r = -1
rp = [[0, 0]]
solve(i, j, 0)
rb.append([r, rp])
print(k)
for i in range(n):
for j in range(m):
if d[i][j] != -2:
print('B', i+1, j+1)
for u in rb:
for k in u[1]:
solp(k[0], k[1], u[0])
``` | instruction | 0 | 11,980 | 8 | 23,960 |
No | output | 1 | 11,980 | 8 | 23,961 |
Provide tags and a correct Python 3 solution for this coding contest problem.
Recently, Duff has been practicing weight lifting. As a hard practice, Malek gave her a task. He gave her a sequence of weights. Weight of i-th of them is 2wi pounds. In each step, Duff can lift some of the remaining weights and throw them away. She does this until there's no more weight left. Malek asked her to minimize the number of steps.
<image>
Duff is a competitive programming fan. That's why in each step, she can only lift and throw away a sequence of weights 2a1, ..., 2ak if and only if there exists a non-negative integer x such that 2a1 + 2a2 + ... + 2ak = 2x, i. e. the sum of those numbers is a power of two.
Duff is a competitive programming fan, but not a programmer. That's why she asked for your help. Help her minimize the number of steps.
Input
The first line of input contains integer n (1 ≤ n ≤ 106), the number of weights.
The second line contains n integers w1, ..., wn separated by spaces (0 ≤ wi ≤ 106 for each 1 ≤ i ≤ n), the powers of two forming the weights values.
Output
Print the minimum number of steps in a single line.
Examples
Input
5
1 1 2 3 3
Output
2
Input
4
0 1 2 3
Output
4
Note
In the first sample case: One optimal way would be to throw away the first three in the first step and the rest in the second step. Also, it's not possible to do it in one step because their sum is not a power of two.
In the second sample case: The only optimal way is to throw away one weight in each step. It's not possible to do it in less than 4 steps because there's no subset of weights with more than one weight and sum equal to a power of two. | instruction | 0 | 12,057 | 8 | 24,114 |
Tags: greedy
Correct Solution:
```
n=int(input())
l=list(map(int,input().split()))
cnt=[0]*(10**6+100)
for i in l:
cnt[i]+=1
s=0
ans=0
for i in cnt:
s+=i
ans+=s%2
s//=2
print(ans)
``` | output | 1 | 12,057 | 8 | 24,115 |
Provide tags and a correct Python 3 solution for this coding contest problem.
Recently, Duff has been practicing weight lifting. As a hard practice, Malek gave her a task. He gave her a sequence of weights. Weight of i-th of them is 2wi pounds. In each step, Duff can lift some of the remaining weights and throw them away. She does this until there's no more weight left. Malek asked her to minimize the number of steps.
<image>
Duff is a competitive programming fan. That's why in each step, she can only lift and throw away a sequence of weights 2a1, ..., 2ak if and only if there exists a non-negative integer x such that 2a1 + 2a2 + ... + 2ak = 2x, i. e. the sum of those numbers is a power of two.
Duff is a competitive programming fan, but not a programmer. That's why she asked for your help. Help her minimize the number of steps.
Input
The first line of input contains integer n (1 ≤ n ≤ 106), the number of weights.
The second line contains n integers w1, ..., wn separated by spaces (0 ≤ wi ≤ 106 for each 1 ≤ i ≤ n), the powers of two forming the weights values.
Output
Print the minimum number of steps in a single line.
Examples
Input
5
1 1 2 3 3
Output
2
Input
4
0 1 2 3
Output
4
Note
In the first sample case: One optimal way would be to throw away the first three in the first step and the rest in the second step. Also, it's not possible to do it in one step because their sum is not a power of two.
In the second sample case: The only optimal way is to throw away one weight in each step. It's not possible to do it in less than 4 steps because there's no subset of weights with more than one weight and sum equal to a power of two. | instruction | 0 | 12,060 | 8 | 24,120 |
Tags: greedy
Correct Solution:
```
N = int(1e6) + 20
n = int(input())
m = [0] * N
k = 1e6 + 1
for x in map(int, input().split()):
m[x] += 1
k = min(k, x)
result = 0
while k < N - 1:
v = m[k]
m[k + 1] += v >> 1
result += v & 0x1
k += 1
print(result + m[-1])
``` | output | 1 | 12,060 | 8 | 24,121 |
Provide tags and a correct Python 3 solution for this coding contest problem.
Recently, Duff has been practicing weight lifting. As a hard practice, Malek gave her a task. He gave her a sequence of weights. Weight of i-th of them is 2wi pounds. In each step, Duff can lift some of the remaining weights and throw them away. She does this until there's no more weight left. Malek asked her to minimize the number of steps.
<image>
Duff is a competitive programming fan. That's why in each step, she can only lift and throw away a sequence of weights 2a1, ..., 2ak if and only if there exists a non-negative integer x such that 2a1 + 2a2 + ... + 2ak = 2x, i. e. the sum of those numbers is a power of two.
Duff is a competitive programming fan, but not a programmer. That's why she asked for your help. Help her minimize the number of steps.
Input
The first line of input contains integer n (1 ≤ n ≤ 106), the number of weights.
The second line contains n integers w1, ..., wn separated by spaces (0 ≤ wi ≤ 106 for each 1 ≤ i ≤ n), the powers of two forming the weights values.
Output
Print the minimum number of steps in a single line.
Examples
Input
5
1 1 2 3 3
Output
2
Input
4
0 1 2 3
Output
4
Note
In the first sample case: One optimal way would be to throw away the first three in the first step and the rest in the second step. Also, it's not possible to do it in one step because their sum is not a power of two.
In the second sample case: The only optimal way is to throw away one weight in each step. It's not possible to do it in less than 4 steps because there's no subset of weights with more than one weight and sum equal to a power of two. | instruction | 0 | 12,063 | 8 | 24,126 |
Tags: greedy
Correct Solution:
```
from collections import *
import sys
import math
from functools import reduce
def factors(n):
return set(reduce(list.__add__,([i, n//i] for i in range(1, int(n**0.5) + 1) if n % i == 0)))
def li():return [int(i) for i in input().rstrip('\n').split(' ')]
def st():return input().rstrip('\n')
def val():return int(input())
def stli():return [int(i) for i in input().rstrip('\n')]
def persquare(x):
return 1 if x**0.5 == int(x**0.5) else 0
n = val()
l = sorted(li())
currlist = [0 for i in range(10**6 + 22)]
for i in l:
currlist[i] += 1
tot = 0
# print(currlist[:10])
for i in range(10**6 + 21):
while currlist[i]>1:
temp = 2**int(math.log2(currlist[i]))
currlist[i] -= temp
currlist[i + 1] += temp//2
# print(currlist[:10])
print(sum(currlist))
``` | output | 1 | 12,063 | 8 | 24,127 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
Recently, Duff has been practicing weight lifting. As a hard practice, Malek gave her a task. He gave her a sequence of weights. Weight of i-th of them is 2wi pounds. In each step, Duff can lift some of the remaining weights and throw them away. She does this until there's no more weight left. Malek asked her to minimize the number of steps.
<image>
Duff is a competitive programming fan. That's why in each step, she can only lift and throw away a sequence of weights 2a1, ..., 2ak if and only if there exists a non-negative integer x such that 2a1 + 2a2 + ... + 2ak = 2x, i. e. the sum of those numbers is a power of two.
Duff is a competitive programming fan, but not a programmer. That's why she asked for your help. Help her minimize the number of steps.
Input
The first line of input contains integer n (1 ≤ n ≤ 106), the number of weights.
The second line contains n integers w1, ..., wn separated by spaces (0 ≤ wi ≤ 106 for each 1 ≤ i ≤ n), the powers of two forming the weights values.
Output
Print the minimum number of steps in a single line.
Examples
Input
5
1 1 2 3 3
Output
2
Input
4
0 1 2 3
Output
4
Note
In the first sample case: One optimal way would be to throw away the first three in the first step and the rest in the second step. Also, it's not possible to do it in one step because their sum is not a power of two.
In the second sample case: The only optimal way is to throw away one weight in each step. It's not possible to do it in less than 4 steps because there's no subset of weights with more than one weight and sum equal to a power of two.
Submitted Solution:
```
def inc(a,w):
n=len(a)
i=w
while(i<n and a[i]==1):
a[i]=0
i+=1
if(i<n):
a[i]=1
else:
a.append(1)
n=int(input())
x=input().split(' ')
w=[int(y) for y in x]
a=[0]*1000024
for t in w:
inc(a,t)
print(sum(a))
``` | instruction | 0 | 12,066 | 8 | 24,132 |
Yes | output | 1 | 12,066 | 8 | 24,133 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
Recently, Duff has been practicing weight lifting. As a hard practice, Malek gave her a task. He gave her a sequence of weights. Weight of i-th of them is 2wi pounds. In each step, Duff can lift some of the remaining weights and throw them away. She does this until there's no more weight left. Malek asked her to minimize the number of steps.
<image>
Duff is a competitive programming fan. That's why in each step, she can only lift and throw away a sequence of weights 2a1, ..., 2ak if and only if there exists a non-negative integer x such that 2a1 + 2a2 + ... + 2ak = 2x, i. e. the sum of those numbers is a power of two.
Duff is a competitive programming fan, but not a programmer. That's why she asked for your help. Help her minimize the number of steps.
Input
The first line of input contains integer n (1 ≤ n ≤ 106), the number of weights.
The second line contains n integers w1, ..., wn separated by spaces (0 ≤ wi ≤ 106 for each 1 ≤ i ≤ n), the powers of two forming the weights values.
Output
Print the minimum number of steps in a single line.
Examples
Input
5
1 1 2 3 3
Output
2
Input
4
0 1 2 3
Output
4
Note
In the first sample case: One optimal way would be to throw away the first three in the first step and the rest in the second step. Also, it's not possible to do it in one step because their sum is not a power of two.
In the second sample case: The only optimal way is to throw away one weight in each step. It's not possible to do it in less than 4 steps because there's no subset of weights with more than one weight and sum equal to a power of two.
Submitted Solution:
```
n=4
inputList = '0 1 2 3'
list = [int(x) for x in inputList.split()]
#n = int(input())
#list = [int(x) for x in input().split()]
length = n
previousLength = 0
while length != previousLength:
previousLength = length
for i in range(len(list)-1,0,-1):
if list[i] == list[i-1]:
list[i-1] += list[i]
del list[i]
length = len(list)
print(length)
``` | instruction | 0 | 12,069 | 8 | 24,138 |
No | output | 1 | 12,069 | 8 | 24,139 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
Recently, Duff has been practicing weight lifting. As a hard practice, Malek gave her a task. He gave her a sequence of weights. Weight of i-th of them is 2wi pounds. In each step, Duff can lift some of the remaining weights and throw them away. She does this until there's no more weight left. Malek asked her to minimize the number of steps.
<image>
Duff is a competitive programming fan. That's why in each step, she can only lift and throw away a sequence of weights 2a1, ..., 2ak if and only if there exists a non-negative integer x such that 2a1 + 2a2 + ... + 2ak = 2x, i. e. the sum of those numbers is a power of two.
Duff is a competitive programming fan, but not a programmer. That's why she asked for your help. Help her minimize the number of steps.
Input
The first line of input contains integer n (1 ≤ n ≤ 106), the number of weights.
The second line contains n integers w1, ..., wn separated by spaces (0 ≤ wi ≤ 106 for each 1 ≤ i ≤ n), the powers of two forming the weights values.
Output
Print the minimum number of steps in a single line.
Examples
Input
5
1 1 2 3 3
Output
2
Input
4
0 1 2 3
Output
4
Note
In the first sample case: One optimal way would be to throw away the first three in the first step and the rest in the second step. Also, it's not possible to do it in one step because their sum is not a power of two.
In the second sample case: The only optimal way is to throw away one weight in each step. It's not possible to do it in less than 4 steps because there's no subset of weights with more than one weight and sum equal to a power of two.
Submitted Solution:
```
from collections import *
import sys
import math
from functools import reduce
def factors(n):
return set(reduce(list.__add__,([i, n//i] for i in range(1, int(n**0.5) + 1) if n % i == 0)))
def li():return [int(i) for i in input().rstrip('\n').split(' ')]
def st():return input().rstrip('\n')
def val():return int(input())
def stli():return [int(i) for i in input().rstrip('\n')]
def persquare(x):
return 1 if x**0.5 == int(x**0.5) else 0
n = val()
l = sorted(li())
currlist = [0 for i in range(10**6 + 10)]
for i in l:
currlist[i] += 1
tot = 0
for i in range(10**6 + 10):
while currlist[i]>1:
temp = 2**int(math.log2(currlist[i]))
currlist[i] -= temp
currlist[temp//2] += 1
print(sum(currlist))
``` | instruction | 0 | 12,070 | 8 | 24,140 |
No | output | 1 | 12,070 | 8 | 24,141 |
Provide tags and a correct Python 3 solution for this coding contest problem.
Zane the wizard had never loved anyone before, until he fell in love with a girl, whose name remains unknown to us.
<image>
The girl lives in house m of a village. There are n houses in that village, lining in a straight line from left to right: house 1, house 2, ..., house n. The village is also well-structured: house i and house i + 1 (1 ≤ i < n) are exactly 10 meters away. In this village, some houses are occupied, and some are not. Indeed, unoccupied houses can be purchased.
You will be given n integers a1, a2, ..., an that denote the availability and the prices of the houses. If house i is occupied, and therefore cannot be bought, then ai equals 0. Otherwise, house i can be bought, and ai represents the money required to buy it, in dollars.
As Zane has only k dollars to spare, it becomes a challenge for him to choose the house to purchase, so that he could live as near as possible to his crush. Help Zane determine the minimum distance from his crush's house to some house he can afford, to help him succeed in his love.
Input
The first line contains three integers n, m, and k (2 ≤ n ≤ 100, 1 ≤ m ≤ n, 1 ≤ k ≤ 100) — the number of houses in the village, the house where the girl lives, and the amount of money Zane has (in dollars), respectively.
The second line contains n integers a1, a2, ..., an (0 ≤ ai ≤ 100) — denoting the availability and the prices of the houses.
It is guaranteed that am = 0 and that it is possible to purchase some house with no more than k dollars.
Output
Print one integer — the minimum distance, in meters, from the house where the girl Zane likes lives to the house Zane can buy.
Examples
Input
5 1 20
0 27 32 21 19
Output
40
Input
7 3 50
62 0 0 0 99 33 22
Output
30
Input
10 5 100
1 0 1 0 0 0 0 0 1 1
Output
20
Note
In the first sample, with k = 20 dollars, Zane can buy only house 5. The distance from house m = 1 to house 5 is 10 + 10 + 10 + 10 = 40 meters.
In the second sample, Zane can buy houses 6 and 7. It is better to buy house 6 than house 7, since house m = 3 and house 6 are only 30 meters away, while house m = 3 and house 7 are 40 meters away. | instruction | 0 | 12,162 | 8 | 24,324 |
Tags: brute force, implementation
Correct Solution:
```
n, m, k = map(int,input().split())
s = list(map(int,input().split())); c = []
for i in range(n):
if s[i]<=k and s[i]!=0: c.append(i+1)
ans = 99999999999
for i in range(len(c)):
if abs(m-c[i])<ans:
ans = abs(m-c[i])
print(ans*10)
``` | output | 1 | 12,162 | 8 | 24,325 |
Provide tags and a correct Python 3 solution for this coding contest problem.
Zane the wizard had never loved anyone before, until he fell in love with a girl, whose name remains unknown to us.
<image>
The girl lives in house m of a village. There are n houses in that village, lining in a straight line from left to right: house 1, house 2, ..., house n. The village is also well-structured: house i and house i + 1 (1 ≤ i < n) are exactly 10 meters away. In this village, some houses are occupied, and some are not. Indeed, unoccupied houses can be purchased.
You will be given n integers a1, a2, ..., an that denote the availability and the prices of the houses. If house i is occupied, and therefore cannot be bought, then ai equals 0. Otherwise, house i can be bought, and ai represents the money required to buy it, in dollars.
As Zane has only k dollars to spare, it becomes a challenge for him to choose the house to purchase, so that he could live as near as possible to his crush. Help Zane determine the minimum distance from his crush's house to some house he can afford, to help him succeed in his love.
Input
The first line contains three integers n, m, and k (2 ≤ n ≤ 100, 1 ≤ m ≤ n, 1 ≤ k ≤ 100) — the number of houses in the village, the house where the girl lives, and the amount of money Zane has (in dollars), respectively.
The second line contains n integers a1, a2, ..., an (0 ≤ ai ≤ 100) — denoting the availability and the prices of the houses.
It is guaranteed that am = 0 and that it is possible to purchase some house with no more than k dollars.
Output
Print one integer — the minimum distance, in meters, from the house where the girl Zane likes lives to the house Zane can buy.
Examples
Input
5 1 20
0 27 32 21 19
Output
40
Input
7 3 50
62 0 0 0 99 33 22
Output
30
Input
10 5 100
1 0 1 0 0 0 0 0 1 1
Output
20
Note
In the first sample, with k = 20 dollars, Zane can buy only house 5. The distance from house m = 1 to house 5 is 10 + 10 + 10 + 10 = 40 meters.
In the second sample, Zane can buy houses 6 and 7. It is better to buy house 6 than house 7, since house m = 3 and house 6 are only 30 meters away, while house m = 3 and house 7 are 40 meters away. | instruction | 0 | 12,163 | 8 | 24,326 |
Tags: brute force, implementation
Correct Solution:
```
n, m, k = input().split()
n = int(n)
m = int(m)
k = int(k)
h = input().split()
no_zero = 0
for i in range(len(h)):
h[i] = int(h[i])
if h[i] > k:
h[i] = 0
elif h[i] != 0:
no_zero += 1
min_dis = None
while no_zero:
c = max(h)
i = h.index(c) + 1
if min_dis is None or min_dis > abs(i - m):
min_dis = abs(i - m)
no_zero -= 1
h[i-1] = 0
print(min_dis * 10)
``` | output | 1 | 12,163 | 8 | 24,327 |
Provide tags and a correct Python 3 solution for this coding contest problem.
Zane the wizard had never loved anyone before, until he fell in love with a girl, whose name remains unknown to us.
<image>
The girl lives in house m of a village. There are n houses in that village, lining in a straight line from left to right: house 1, house 2, ..., house n. The village is also well-structured: house i and house i + 1 (1 ≤ i < n) are exactly 10 meters away. In this village, some houses are occupied, and some are not. Indeed, unoccupied houses can be purchased.
You will be given n integers a1, a2, ..., an that denote the availability and the prices of the houses. If house i is occupied, and therefore cannot be bought, then ai equals 0. Otherwise, house i can be bought, and ai represents the money required to buy it, in dollars.
As Zane has only k dollars to spare, it becomes a challenge for him to choose the house to purchase, so that he could live as near as possible to his crush. Help Zane determine the minimum distance from his crush's house to some house he can afford, to help him succeed in his love.
Input
The first line contains three integers n, m, and k (2 ≤ n ≤ 100, 1 ≤ m ≤ n, 1 ≤ k ≤ 100) — the number of houses in the village, the house where the girl lives, and the amount of money Zane has (in dollars), respectively.
The second line contains n integers a1, a2, ..., an (0 ≤ ai ≤ 100) — denoting the availability and the prices of the houses.
It is guaranteed that am = 0 and that it is possible to purchase some house with no more than k dollars.
Output
Print one integer — the minimum distance, in meters, from the house where the girl Zane likes lives to the house Zane can buy.
Examples
Input
5 1 20
0 27 32 21 19
Output
40
Input
7 3 50
62 0 0 0 99 33 22
Output
30
Input
10 5 100
1 0 1 0 0 0 0 0 1 1
Output
20
Note
In the first sample, with k = 20 dollars, Zane can buy only house 5. The distance from house m = 1 to house 5 is 10 + 10 + 10 + 10 = 40 meters.
In the second sample, Zane can buy houses 6 and 7. It is better to buy house 6 than house 7, since house m = 3 and house 6 are only 30 meters away, while house m = 3 and house 7 are 40 meters away. | instruction | 0 | 12,164 | 8 | 24,328 |
Tags: brute force, implementation
Correct Solution:
```
N, M, K = map(int, input().split())
lista = [int(i) for i in input().split()]
k, ans=0, []
for i in lista:
k += 1
if(i!=0 and i<=K):
ans.append(abs(k-M))
ans.sort()
print(ans[0]*10)
``` | output | 1 | 12,164 | 8 | 24,329 |
Provide tags and a correct Python 3 solution for this coding contest problem.
Zane the wizard had never loved anyone before, until he fell in love with a girl, whose name remains unknown to us.
<image>
The girl lives in house m of a village. There are n houses in that village, lining in a straight line from left to right: house 1, house 2, ..., house n. The village is also well-structured: house i and house i + 1 (1 ≤ i < n) are exactly 10 meters away. In this village, some houses are occupied, and some are not. Indeed, unoccupied houses can be purchased.
You will be given n integers a1, a2, ..., an that denote the availability and the prices of the houses. If house i is occupied, and therefore cannot be bought, then ai equals 0. Otherwise, house i can be bought, and ai represents the money required to buy it, in dollars.
As Zane has only k dollars to spare, it becomes a challenge for him to choose the house to purchase, so that he could live as near as possible to his crush. Help Zane determine the minimum distance from his crush's house to some house he can afford, to help him succeed in his love.
Input
The first line contains three integers n, m, and k (2 ≤ n ≤ 100, 1 ≤ m ≤ n, 1 ≤ k ≤ 100) — the number of houses in the village, the house where the girl lives, and the amount of money Zane has (in dollars), respectively.
The second line contains n integers a1, a2, ..., an (0 ≤ ai ≤ 100) — denoting the availability and the prices of the houses.
It is guaranteed that am = 0 and that it is possible to purchase some house with no more than k dollars.
Output
Print one integer — the minimum distance, in meters, from the house where the girl Zane likes lives to the house Zane can buy.
Examples
Input
5 1 20
0 27 32 21 19
Output
40
Input
7 3 50
62 0 0 0 99 33 22
Output
30
Input
10 5 100
1 0 1 0 0 0 0 0 1 1
Output
20
Note
In the first sample, with k = 20 dollars, Zane can buy only house 5. The distance from house m = 1 to house 5 is 10 + 10 + 10 + 10 = 40 meters.
In the second sample, Zane can buy houses 6 and 7. It is better to buy house 6 than house 7, since house m = 3 and house 6 are only 30 meters away, while house m = 3 and house 7 are 40 meters away. | instruction | 0 | 12,165 | 8 | 24,330 |
Tags: brute force, implementation
Correct Solution:
```
n, m, k = list(map(int, input().split()))
a = list(map(int, input().split()))
r = 10000
for i in range(n):
if a[i] <= k and a[i] != 0:
r = min(r, abs(m-i-1))
print(r*10)
``` | output | 1 | 12,165 | 8 | 24,331 |
Provide tags and a correct Python 3 solution for this coding contest problem.
Zane the wizard had never loved anyone before, until he fell in love with a girl, whose name remains unknown to us.
<image>
The girl lives in house m of a village. There are n houses in that village, lining in a straight line from left to right: house 1, house 2, ..., house n. The village is also well-structured: house i and house i + 1 (1 ≤ i < n) are exactly 10 meters away. In this village, some houses are occupied, and some are not. Indeed, unoccupied houses can be purchased.
You will be given n integers a1, a2, ..., an that denote the availability and the prices of the houses. If house i is occupied, and therefore cannot be bought, then ai equals 0. Otherwise, house i can be bought, and ai represents the money required to buy it, in dollars.
As Zane has only k dollars to spare, it becomes a challenge for him to choose the house to purchase, so that he could live as near as possible to his crush. Help Zane determine the minimum distance from his crush's house to some house he can afford, to help him succeed in his love.
Input
The first line contains three integers n, m, and k (2 ≤ n ≤ 100, 1 ≤ m ≤ n, 1 ≤ k ≤ 100) — the number of houses in the village, the house where the girl lives, and the amount of money Zane has (in dollars), respectively.
The second line contains n integers a1, a2, ..., an (0 ≤ ai ≤ 100) — denoting the availability and the prices of the houses.
It is guaranteed that am = 0 and that it is possible to purchase some house with no more than k dollars.
Output
Print one integer — the minimum distance, in meters, from the house where the girl Zane likes lives to the house Zane can buy.
Examples
Input
5 1 20
0 27 32 21 19
Output
40
Input
7 3 50
62 0 0 0 99 33 22
Output
30
Input
10 5 100
1 0 1 0 0 0 0 0 1 1
Output
20
Note
In the first sample, with k = 20 dollars, Zane can buy only house 5. The distance from house m = 1 to house 5 is 10 + 10 + 10 + 10 = 40 meters.
In the second sample, Zane can buy houses 6 and 7. It is better to buy house 6 than house 7, since house m = 3 and house 6 are only 30 meters away, while house m = 3 and house 7 are 40 meters away. | instruction | 0 | 12,166 | 8 | 24,332 |
Tags: brute force, implementation
Correct Solution:
```
n,m,k=map(int,input().split())
a=list(map(int,input().split()))
b=[]
for y in range(0,n):
if k>=a[y] and a[y]!=0:
b.append(abs(y-(m-1)))
l=min(b)
print(l*10)
``` | output | 1 | 12,166 | 8 | 24,333 |
Provide tags and a correct Python 3 solution for this coding contest problem.
Zane the wizard had never loved anyone before, until he fell in love with a girl, whose name remains unknown to us.
<image>
The girl lives in house m of a village. There are n houses in that village, lining in a straight line from left to right: house 1, house 2, ..., house n. The village is also well-structured: house i and house i + 1 (1 ≤ i < n) are exactly 10 meters away. In this village, some houses are occupied, and some are not. Indeed, unoccupied houses can be purchased.
You will be given n integers a1, a2, ..., an that denote the availability and the prices of the houses. If house i is occupied, and therefore cannot be bought, then ai equals 0. Otherwise, house i can be bought, and ai represents the money required to buy it, in dollars.
As Zane has only k dollars to spare, it becomes a challenge for him to choose the house to purchase, so that he could live as near as possible to his crush. Help Zane determine the minimum distance from his crush's house to some house he can afford, to help him succeed in his love.
Input
The first line contains three integers n, m, and k (2 ≤ n ≤ 100, 1 ≤ m ≤ n, 1 ≤ k ≤ 100) — the number of houses in the village, the house where the girl lives, and the amount of money Zane has (in dollars), respectively.
The second line contains n integers a1, a2, ..., an (0 ≤ ai ≤ 100) — denoting the availability and the prices of the houses.
It is guaranteed that am = 0 and that it is possible to purchase some house with no more than k dollars.
Output
Print one integer — the minimum distance, in meters, from the house where the girl Zane likes lives to the house Zane can buy.
Examples
Input
5 1 20
0 27 32 21 19
Output
40
Input
7 3 50
62 0 0 0 99 33 22
Output
30
Input
10 5 100
1 0 1 0 0 0 0 0 1 1
Output
20
Note
In the first sample, with k = 20 dollars, Zane can buy only house 5. The distance from house m = 1 to house 5 is 10 + 10 + 10 + 10 = 40 meters.
In the second sample, Zane can buy houses 6 and 7. It is better to buy house 6 than house 7, since house m = 3 and house 6 are only 30 meters away, while house m = 3 and house 7 are 40 meters away. | instruction | 0 | 12,167 | 8 | 24,334 |
Tags: brute force, implementation
Correct Solution:
```
n,m,k=map(int,input().split())
a=list(map(int,input().split()))
mi=int (1e9)
for i in range(m,n):
if a[i]<=k and a[i]!=0:
mi=min(mi,i-m+1)
for i in range(max(0,m-2),-1,-1):
if a[i]<=k and a[i]!=0:
mi=min(mi,m-1-i)
print(mi*10)
``` | output | 1 | 12,167 | 8 | 24,335 |
Provide tags and a correct Python 3 solution for this coding contest problem.
Zane the wizard had never loved anyone before, until he fell in love with a girl, whose name remains unknown to us.
<image>
The girl lives in house m of a village. There are n houses in that village, lining in a straight line from left to right: house 1, house 2, ..., house n. The village is also well-structured: house i and house i + 1 (1 ≤ i < n) are exactly 10 meters away. In this village, some houses are occupied, and some are not. Indeed, unoccupied houses can be purchased.
You will be given n integers a1, a2, ..., an that denote the availability and the prices of the houses. If house i is occupied, and therefore cannot be bought, then ai equals 0. Otherwise, house i can be bought, and ai represents the money required to buy it, in dollars.
As Zane has only k dollars to spare, it becomes a challenge for him to choose the house to purchase, so that he could live as near as possible to his crush. Help Zane determine the minimum distance from his crush's house to some house he can afford, to help him succeed in his love.
Input
The first line contains three integers n, m, and k (2 ≤ n ≤ 100, 1 ≤ m ≤ n, 1 ≤ k ≤ 100) — the number of houses in the village, the house where the girl lives, and the amount of money Zane has (in dollars), respectively.
The second line contains n integers a1, a2, ..., an (0 ≤ ai ≤ 100) — denoting the availability and the prices of the houses.
It is guaranteed that am = 0 and that it is possible to purchase some house with no more than k dollars.
Output
Print one integer — the minimum distance, in meters, from the house where the girl Zane likes lives to the house Zane can buy.
Examples
Input
5 1 20
0 27 32 21 19
Output
40
Input
7 3 50
62 0 0 0 99 33 22
Output
30
Input
10 5 100
1 0 1 0 0 0 0 0 1 1
Output
20
Note
In the first sample, with k = 20 dollars, Zane can buy only house 5. The distance from house m = 1 to house 5 is 10 + 10 + 10 + 10 = 40 meters.
In the second sample, Zane can buy houses 6 and 7. It is better to buy house 6 than house 7, since house m = 3 and house 6 are only 30 meters away, while house m = 3 and house 7 are 40 meters away. | instruction | 0 | 12,168 | 8 | 24,336 |
Tags: brute force, implementation
Correct Solution:
```
import sys
lineno = 0
for l in sys.stdin:
if lineno == 0:
[n, m, k] = [int(i) for i in str(l).strip().split()]
if lineno == 1:
p = [int(i) for i in l.strip().split()]
p = [10*abs(d - (m - 1)) for (i, d) in zip(p, range(len(p)))
if (i != 0 and i <= k)]
print(min(p))
lineno += 1
``` | output | 1 | 12,168 | 8 | 24,337 |
Provide tags and a correct Python 3 solution for this coding contest problem.
Zane the wizard had never loved anyone before, until he fell in love with a girl, whose name remains unknown to us.
<image>
The girl lives in house m of a village. There are n houses in that village, lining in a straight line from left to right: house 1, house 2, ..., house n. The village is also well-structured: house i and house i + 1 (1 ≤ i < n) are exactly 10 meters away. In this village, some houses are occupied, and some are not. Indeed, unoccupied houses can be purchased.
You will be given n integers a1, a2, ..., an that denote the availability and the prices of the houses. If house i is occupied, and therefore cannot be bought, then ai equals 0. Otherwise, house i can be bought, and ai represents the money required to buy it, in dollars.
As Zane has only k dollars to spare, it becomes a challenge for him to choose the house to purchase, so that he could live as near as possible to his crush. Help Zane determine the minimum distance from his crush's house to some house he can afford, to help him succeed in his love.
Input
The first line contains three integers n, m, and k (2 ≤ n ≤ 100, 1 ≤ m ≤ n, 1 ≤ k ≤ 100) — the number of houses in the village, the house where the girl lives, and the amount of money Zane has (in dollars), respectively.
The second line contains n integers a1, a2, ..., an (0 ≤ ai ≤ 100) — denoting the availability and the prices of the houses.
It is guaranteed that am = 0 and that it is possible to purchase some house with no more than k dollars.
Output
Print one integer — the minimum distance, in meters, from the house where the girl Zane likes lives to the house Zane can buy.
Examples
Input
5 1 20
0 27 32 21 19
Output
40
Input
7 3 50
62 0 0 0 99 33 22
Output
30
Input
10 5 100
1 0 1 0 0 0 0 0 1 1
Output
20
Note
In the first sample, with k = 20 dollars, Zane can buy only house 5. The distance from house m = 1 to house 5 is 10 + 10 + 10 + 10 = 40 meters.
In the second sample, Zane can buy houses 6 and 7. It is better to buy house 6 than house 7, since house m = 3 and house 6 are only 30 meters away, while house m = 3 and house 7 are 40 meters away. | instruction | 0 | 12,169 | 8 | 24,338 |
Tags: brute force, implementation
Correct Solution:
```
n,m,k=map(int,input().split())
a=list(map(int,input().split()))
min1=float("inf")
for i in range(n):
if a[i]!=0 and min1>(abs( (m-1)-(i) )*10) and a[i]<=k:
min1=(abs( (m-1)-(i) )*10)
print(min1)
``` | output | 1 | 12,169 | 8 | 24,339 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
Zane the wizard had never loved anyone before, until he fell in love with a girl, whose name remains unknown to us.
<image>
The girl lives in house m of a village. There are n houses in that village, lining in a straight line from left to right: house 1, house 2, ..., house n. The village is also well-structured: house i and house i + 1 (1 ≤ i < n) are exactly 10 meters away. In this village, some houses are occupied, and some are not. Indeed, unoccupied houses can be purchased.
You will be given n integers a1, a2, ..., an that denote the availability and the prices of the houses. If house i is occupied, and therefore cannot be bought, then ai equals 0. Otherwise, house i can be bought, and ai represents the money required to buy it, in dollars.
As Zane has only k dollars to spare, it becomes a challenge for him to choose the house to purchase, so that he could live as near as possible to his crush. Help Zane determine the minimum distance from his crush's house to some house he can afford, to help him succeed in his love.
Input
The first line contains three integers n, m, and k (2 ≤ n ≤ 100, 1 ≤ m ≤ n, 1 ≤ k ≤ 100) — the number of houses in the village, the house where the girl lives, and the amount of money Zane has (in dollars), respectively.
The second line contains n integers a1, a2, ..., an (0 ≤ ai ≤ 100) — denoting the availability and the prices of the houses.
It is guaranteed that am = 0 and that it is possible to purchase some house with no more than k dollars.
Output
Print one integer — the minimum distance, in meters, from the house where the girl Zane likes lives to the house Zane can buy.
Examples
Input
5 1 20
0 27 32 21 19
Output
40
Input
7 3 50
62 0 0 0 99 33 22
Output
30
Input
10 5 100
1 0 1 0 0 0 0 0 1 1
Output
20
Note
In the first sample, with k = 20 dollars, Zane can buy only house 5. The distance from house m = 1 to house 5 is 10 + 10 + 10 + 10 = 40 meters.
In the second sample, Zane can buy houses 6 and 7. It is better to buy house 6 than house 7, since house m = 3 and house 6 are only 30 meters away, while house m = 3 and house 7 are 40 meters away.
Submitted Solution:
```
n,m,k=input().split()
n=int(n)
m=int(m)
k=int(k)
d=list(input().split())
for i in range(n):
d[i]=int(d[i])
ans=0x3f3f3f3f
l1=list(range(m-1))
l1=l1[::-1]
for i in l1:
if d[i]!=0 and k>=d[i]:
ans=m-i-1
break
for i in range(m,n):
if d[i]!=0 and k>=d[i]:
ans=min(ans,i-m+1)
break
print(ans*10)
``` | instruction | 0 | 12,170 | 8 | 24,340 |
Yes | output | 1 | 12,170 | 8 | 24,341 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
Zane the wizard had never loved anyone before, until he fell in love with a girl, whose name remains unknown to us.
<image>
The girl lives in house m of a village. There are n houses in that village, lining in a straight line from left to right: house 1, house 2, ..., house n. The village is also well-structured: house i and house i + 1 (1 ≤ i < n) are exactly 10 meters away. In this village, some houses are occupied, and some are not. Indeed, unoccupied houses can be purchased.
You will be given n integers a1, a2, ..., an that denote the availability and the prices of the houses. If house i is occupied, and therefore cannot be bought, then ai equals 0. Otherwise, house i can be bought, and ai represents the money required to buy it, in dollars.
As Zane has only k dollars to spare, it becomes a challenge for him to choose the house to purchase, so that he could live as near as possible to his crush. Help Zane determine the minimum distance from his crush's house to some house he can afford, to help him succeed in his love.
Input
The first line contains three integers n, m, and k (2 ≤ n ≤ 100, 1 ≤ m ≤ n, 1 ≤ k ≤ 100) — the number of houses in the village, the house where the girl lives, and the amount of money Zane has (in dollars), respectively.
The second line contains n integers a1, a2, ..., an (0 ≤ ai ≤ 100) — denoting the availability and the prices of the houses.
It is guaranteed that am = 0 and that it is possible to purchase some house with no more than k dollars.
Output
Print one integer — the minimum distance, in meters, from the house where the girl Zane likes lives to the house Zane can buy.
Examples
Input
5 1 20
0 27 32 21 19
Output
40
Input
7 3 50
62 0 0 0 99 33 22
Output
30
Input
10 5 100
1 0 1 0 0 0 0 0 1 1
Output
20
Note
In the first sample, with k = 20 dollars, Zane can buy only house 5. The distance from house m = 1 to house 5 is 10 + 10 + 10 + 10 = 40 meters.
In the second sample, Zane can buy houses 6 and 7. It is better to buy house 6 than house 7, since house m = 3 and house 6 are only 30 meters away, while house m = 3 and house 7 are 40 meters away.
Submitted Solution:
```
initial = input()
pricing = input()
first_line = list(map(int,initial.split()))
second_line = list(map(int,pricing.split()))
available = first_line[0]
her_house = first_line[1] - 1
money = first_line[2]
current_best = 1000000000
current = 99999999
for index, item in enumerate(second_line):
if item <= money and item != 0:
current = abs(index - her_house) * 10
if current < current_best:
current_best = current
print(current_best)
``` | instruction | 0 | 12,171 | 8 | 24,342 |
Yes | output | 1 | 12,171 | 8 | 24,343 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
Zane the wizard had never loved anyone before, until he fell in love with a girl, whose name remains unknown to us.
<image>
The girl lives in house m of a village. There are n houses in that village, lining in a straight line from left to right: house 1, house 2, ..., house n. The village is also well-structured: house i and house i + 1 (1 ≤ i < n) are exactly 10 meters away. In this village, some houses are occupied, and some are not. Indeed, unoccupied houses can be purchased.
You will be given n integers a1, a2, ..., an that denote the availability and the prices of the houses. If house i is occupied, and therefore cannot be bought, then ai equals 0. Otherwise, house i can be bought, and ai represents the money required to buy it, in dollars.
As Zane has only k dollars to spare, it becomes a challenge for him to choose the house to purchase, so that he could live as near as possible to his crush. Help Zane determine the minimum distance from his crush's house to some house he can afford, to help him succeed in his love.
Input
The first line contains three integers n, m, and k (2 ≤ n ≤ 100, 1 ≤ m ≤ n, 1 ≤ k ≤ 100) — the number of houses in the village, the house where the girl lives, and the amount of money Zane has (in dollars), respectively.
The second line contains n integers a1, a2, ..., an (0 ≤ ai ≤ 100) — denoting the availability and the prices of the houses.
It is guaranteed that am = 0 and that it is possible to purchase some house with no more than k dollars.
Output
Print one integer — the minimum distance, in meters, from the house where the girl Zane likes lives to the house Zane can buy.
Examples
Input
5 1 20
0 27 32 21 19
Output
40
Input
7 3 50
62 0 0 0 99 33 22
Output
30
Input
10 5 100
1 0 1 0 0 0 0 0 1 1
Output
20
Note
In the first sample, with k = 20 dollars, Zane can buy only house 5. The distance from house m = 1 to house 5 is 10 + 10 + 10 + 10 = 40 meters.
In the second sample, Zane can buy houses 6 and 7. It is better to buy house 6 than house 7, since house m = 3 and house 6 are only 30 meters away, while house m = 3 and house 7 are 40 meters away.
Submitted Solution:
```
n,m,sum=map(int,input().split())
a=[int(i)for i in input().split()]
ans=n+1
for i in range(n):
if(i==m-1):
continue;
else:
if(a[i]==0):
continue
else:
if(a[i]<=sum):
ans=min(ans,abs(m-i-1))
print(ans*10)
``` | instruction | 0 | 12,172 | 8 | 24,344 |
Yes | output | 1 | 12,172 | 8 | 24,345 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
Zane the wizard had never loved anyone before, until he fell in love with a girl, whose name remains unknown to us.
<image>
The girl lives in house m of a village. There are n houses in that village, lining in a straight line from left to right: house 1, house 2, ..., house n. The village is also well-structured: house i and house i + 1 (1 ≤ i < n) are exactly 10 meters away. In this village, some houses are occupied, and some are not. Indeed, unoccupied houses can be purchased.
You will be given n integers a1, a2, ..., an that denote the availability and the prices of the houses. If house i is occupied, and therefore cannot be bought, then ai equals 0. Otherwise, house i can be bought, and ai represents the money required to buy it, in dollars.
As Zane has only k dollars to spare, it becomes a challenge for him to choose the house to purchase, so that he could live as near as possible to his crush. Help Zane determine the minimum distance from his crush's house to some house he can afford, to help him succeed in his love.
Input
The first line contains three integers n, m, and k (2 ≤ n ≤ 100, 1 ≤ m ≤ n, 1 ≤ k ≤ 100) — the number of houses in the village, the house where the girl lives, and the amount of money Zane has (in dollars), respectively.
The second line contains n integers a1, a2, ..., an (0 ≤ ai ≤ 100) — denoting the availability and the prices of the houses.
It is guaranteed that am = 0 and that it is possible to purchase some house with no more than k dollars.
Output
Print one integer — the minimum distance, in meters, from the house where the girl Zane likes lives to the house Zane can buy.
Examples
Input
5 1 20
0 27 32 21 19
Output
40
Input
7 3 50
62 0 0 0 99 33 22
Output
30
Input
10 5 100
1 0 1 0 0 0 0 0 1 1
Output
20
Note
In the first sample, with k = 20 dollars, Zane can buy only house 5. The distance from house m = 1 to house 5 is 10 + 10 + 10 + 10 = 40 meters.
In the second sample, Zane can buy houses 6 and 7. It is better to buy house 6 than house 7, since house m = 3 and house 6 are only 30 meters away, while house m = 3 and house 7 are 40 meters away.
Submitted Solution:
```
if __name__ == "__main__":
nmk = input().split(' ')
for i in range(len(nmk)):
nmk[i] = int(nmk[i])
m = nmk[1]
k = nmk[2]
prices = input().split(' ')
for i in range(len(prices)):
prices[i] = int(prices[i])
avail_houses = list()
for i in range(len(prices)):
if prices[i] != 0 and k >= prices[i]:
avail_houses.append(i+1)
min_dist = len(prices)
for h in avail_houses:
if h - m < min_dist:
min_dist = abs(h - m)
print(min_dist*10)
``` | instruction | 0 | 12,173 | 8 | 24,346 |
Yes | output | 1 | 12,173 | 8 | 24,347 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
Zane the wizard had never loved anyone before, until he fell in love with a girl, whose name remains unknown to us.
<image>
The girl lives in house m of a village. There are n houses in that village, lining in a straight line from left to right: house 1, house 2, ..., house n. The village is also well-structured: house i and house i + 1 (1 ≤ i < n) are exactly 10 meters away. In this village, some houses are occupied, and some are not. Indeed, unoccupied houses can be purchased.
You will be given n integers a1, a2, ..., an that denote the availability and the prices of the houses. If house i is occupied, and therefore cannot be bought, then ai equals 0. Otherwise, house i can be bought, and ai represents the money required to buy it, in dollars.
As Zane has only k dollars to spare, it becomes a challenge for him to choose the house to purchase, so that he could live as near as possible to his crush. Help Zane determine the minimum distance from his crush's house to some house he can afford, to help him succeed in his love.
Input
The first line contains three integers n, m, and k (2 ≤ n ≤ 100, 1 ≤ m ≤ n, 1 ≤ k ≤ 100) — the number of houses in the village, the house where the girl lives, and the amount of money Zane has (in dollars), respectively.
The second line contains n integers a1, a2, ..., an (0 ≤ ai ≤ 100) — denoting the availability and the prices of the houses.
It is guaranteed that am = 0 and that it is possible to purchase some house with no more than k dollars.
Output
Print one integer — the minimum distance, in meters, from the house where the girl Zane likes lives to the house Zane can buy.
Examples
Input
5 1 20
0 27 32 21 19
Output
40
Input
7 3 50
62 0 0 0 99 33 22
Output
30
Input
10 5 100
1 0 1 0 0 0 0 0 1 1
Output
20
Note
In the first sample, with k = 20 dollars, Zane can buy only house 5. The distance from house m = 1 to house 5 is 10 + 10 + 10 + 10 = 40 meters.
In the second sample, Zane can buy houses 6 and 7. It is better to buy house 6 than house 7, since house m = 3 and house 6 are only 30 meters away, while house m = 3 and house 7 are 40 meters away.
Submitted Solution:
```
n, m, k = map(int, input().split())
costs = [int(x) for x in input().split()]
m -= 1
for i in range (1, n):
if (m+i < n and costs[m+i] <= k) or ( m-i >= 0 and costs[m-i] <= k):
print(10*i)
exit(0)
``` | instruction | 0 | 12,174 | 8 | 24,348 |
No | output | 1 | 12,174 | 8 | 24,349 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
Zane the wizard had never loved anyone before, until he fell in love with a girl, whose name remains unknown to us.
<image>
The girl lives in house m of a village. There are n houses in that village, lining in a straight line from left to right: house 1, house 2, ..., house n. The village is also well-structured: house i and house i + 1 (1 ≤ i < n) are exactly 10 meters away. In this village, some houses are occupied, and some are not. Indeed, unoccupied houses can be purchased.
You will be given n integers a1, a2, ..., an that denote the availability and the prices of the houses. If house i is occupied, and therefore cannot be bought, then ai equals 0. Otherwise, house i can be bought, and ai represents the money required to buy it, in dollars.
As Zane has only k dollars to spare, it becomes a challenge for him to choose the house to purchase, so that he could live as near as possible to his crush. Help Zane determine the minimum distance from his crush's house to some house he can afford, to help him succeed in his love.
Input
The first line contains three integers n, m, and k (2 ≤ n ≤ 100, 1 ≤ m ≤ n, 1 ≤ k ≤ 100) — the number of houses in the village, the house where the girl lives, and the amount of money Zane has (in dollars), respectively.
The second line contains n integers a1, a2, ..., an (0 ≤ ai ≤ 100) — denoting the availability and the prices of the houses.
It is guaranteed that am = 0 and that it is possible to purchase some house with no more than k dollars.
Output
Print one integer — the minimum distance, in meters, from the house where the girl Zane likes lives to the house Zane can buy.
Examples
Input
5 1 20
0 27 32 21 19
Output
40
Input
7 3 50
62 0 0 0 99 33 22
Output
30
Input
10 5 100
1 0 1 0 0 0 0 0 1 1
Output
20
Note
In the first sample, with k = 20 dollars, Zane can buy only house 5. The distance from house m = 1 to house 5 is 10 + 10 + 10 + 10 = 40 meters.
In the second sample, Zane can buy houses 6 and 7. It is better to buy house 6 than house 7, since house m = 3 and house 6 are only 30 meters away, while house m = 3 and house 7 are 40 meters away.
Submitted Solution:
```
n,m,k=map(int,input().split())
a=[int(i) for i in input().split()]
ans=100
for i in range(m,n,1):
if a[i]>0 and a[i]<=k:
ans=i-m+1
break
for j in range(m-2,-1,-1):
print(j)
if a[j]>0 and a[j]<=k:
ans=min(ans,m-j+1)
break
print(ans*10)
``` | instruction | 0 | 12,175 | 8 | 24,350 |
No | output | 1 | 12,175 | 8 | 24,351 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
Zane the wizard had never loved anyone before, until he fell in love with a girl, whose name remains unknown to us.
<image>
The girl lives in house m of a village. There are n houses in that village, lining in a straight line from left to right: house 1, house 2, ..., house n. The village is also well-structured: house i and house i + 1 (1 ≤ i < n) are exactly 10 meters away. In this village, some houses are occupied, and some are not. Indeed, unoccupied houses can be purchased.
You will be given n integers a1, a2, ..., an that denote the availability and the prices of the houses. If house i is occupied, and therefore cannot be bought, then ai equals 0. Otherwise, house i can be bought, and ai represents the money required to buy it, in dollars.
As Zane has only k dollars to spare, it becomes a challenge for him to choose the house to purchase, so that he could live as near as possible to his crush. Help Zane determine the minimum distance from his crush's house to some house he can afford, to help him succeed in his love.
Input
The first line contains three integers n, m, and k (2 ≤ n ≤ 100, 1 ≤ m ≤ n, 1 ≤ k ≤ 100) — the number of houses in the village, the house where the girl lives, and the amount of money Zane has (in dollars), respectively.
The second line contains n integers a1, a2, ..., an (0 ≤ ai ≤ 100) — denoting the availability and the prices of the houses.
It is guaranteed that am = 0 and that it is possible to purchase some house with no more than k dollars.
Output
Print one integer — the minimum distance, in meters, from the house where the girl Zane likes lives to the house Zane can buy.
Examples
Input
5 1 20
0 27 32 21 19
Output
40
Input
7 3 50
62 0 0 0 99 33 22
Output
30
Input
10 5 100
1 0 1 0 0 0 0 0 1 1
Output
20
Note
In the first sample, with k = 20 dollars, Zane can buy only house 5. The distance from house m = 1 to house 5 is 10 + 10 + 10 + 10 = 40 meters.
In the second sample, Zane can buy houses 6 and 7. It is better to buy house 6 than house 7, since house m = 3 and house 6 are only 30 meters away, while house m = 3 and house 7 are 40 meters away.
Submitted Solution:
```
a,b,c=input().split()
houses=int(a)
girl=int(b)
money=int(c)
costs=input().split()
closest=100
for i in range(houses):
if int(costs[i])<=money and abs(i-girl)<closest and int(costs[i])>0:
closest=i
print(closest*10)
``` | instruction | 0 | 12,176 | 8 | 24,352 |
No | output | 1 | 12,176 | 8 | 24,353 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
Zane the wizard had never loved anyone before, until he fell in love with a girl, whose name remains unknown to us.
<image>
The girl lives in house m of a village. There are n houses in that village, lining in a straight line from left to right: house 1, house 2, ..., house n. The village is also well-structured: house i and house i + 1 (1 ≤ i < n) are exactly 10 meters away. In this village, some houses are occupied, and some are not. Indeed, unoccupied houses can be purchased.
You will be given n integers a1, a2, ..., an that denote the availability and the prices of the houses. If house i is occupied, and therefore cannot be bought, then ai equals 0. Otherwise, house i can be bought, and ai represents the money required to buy it, in dollars.
As Zane has only k dollars to spare, it becomes a challenge for him to choose the house to purchase, so that he could live as near as possible to his crush. Help Zane determine the minimum distance from his crush's house to some house he can afford, to help him succeed in his love.
Input
The first line contains three integers n, m, and k (2 ≤ n ≤ 100, 1 ≤ m ≤ n, 1 ≤ k ≤ 100) — the number of houses in the village, the house where the girl lives, and the amount of money Zane has (in dollars), respectively.
The second line contains n integers a1, a2, ..., an (0 ≤ ai ≤ 100) — denoting the availability and the prices of the houses.
It is guaranteed that am = 0 and that it is possible to purchase some house with no more than k dollars.
Output
Print one integer — the minimum distance, in meters, from the house where the girl Zane likes lives to the house Zane can buy.
Examples
Input
5 1 20
0 27 32 21 19
Output
40
Input
7 3 50
62 0 0 0 99 33 22
Output
30
Input
10 5 100
1 0 1 0 0 0 0 0 1 1
Output
20
Note
In the first sample, with k = 20 dollars, Zane can buy only house 5. The distance from house m = 1 to house 5 is 10 + 10 + 10 + 10 = 40 meters.
In the second sample, Zane can buy houses 6 and 7. It is better to buy house 6 than house 7, since house m = 3 and house 6 are only 30 meters away, while house m = 3 and house 7 are 40 meters away.
Submitted Solution:
```
input1 = input()
num_house , girl_house , money = map(int,input1.split(' '))
input2 = input()
money_list = list(map(int,input2.split(' ')))
for i in range(len(money_list)):
if money_list[i] == 0:
False
elif money_list[i]<=money:
g_house = girl_house-1
distance = i - g_house
if distance<0:
distance *= -1
else:
print(distance*10)
break
``` | instruction | 0 | 12,177 | 8 | 24,354 |
No | output | 1 | 12,177 | 8 | 24,355 |
Provide tags and a correct Python 3 solution for this coding contest problem.
Petya has equal wooden bars of length n. He wants to make a frame for two equal doors. Each frame has two vertical (left and right) sides of length a and one top side of length b. A solid (i.e. continuous without breaks) piece of bar is needed for each side.
Determine a minimal number of wooden bars which are needed to make the frames for two doors. Petya can cut the wooden bars into any parts, but each side of each door should be a solid piece of a wooden bar (or a whole wooden bar).
Input
The first line contains a single integer n (1 ≤ n ≤ 1 000) — the length of each wooden bar.
The second line contains a single integer a (1 ≤ a ≤ n) — the length of the vertical (left and right) sides of a door frame.
The third line contains a single integer b (1 ≤ b ≤ n) — the length of the upper side of a door frame.
Output
Print the minimal number of wooden bars with length n which are needed to make the frames for two doors.
Examples
Input
8
1
2
Output
1
Input
5
3
4
Output
6
Input
6
4
2
Output
4
Input
20
5
6
Output
2
Note
In the first example one wooden bar is enough, since the total length of all six sides of the frames for two doors is 8.
In the second example 6 wooden bars is enough, because for each side of the frames the new wooden bar is needed. | instruction | 0 | 12,243 | 8 | 24,486 |
Tags: greedy, implementation
Correct Solution:
```
n = int(input())
a = int(input())
b = int(input())
ans = 6
cnt = 0
cur = 2
cnt += 2 * ((n - b) // a)
while cnt < 4:
cur += 1
cnt += (n // a)
ans = min(ans, cur)
if b * 2 <= n:
cur, cnt = 0, 0
cur = 1
cnt += ((n - 2 * b) // a)
while cnt < 4:
cur += 1
cnt += (n // a)
ans = min(ans, cur)
print(ans)
``` | output | 1 | 12,243 | 8 | 24,487 |
Provide tags and a correct Python 3 solution for this coding contest problem.
Petya has equal wooden bars of length n. He wants to make a frame for two equal doors. Each frame has two vertical (left and right) sides of length a and one top side of length b. A solid (i.e. continuous without breaks) piece of bar is needed for each side.
Determine a minimal number of wooden bars which are needed to make the frames for two doors. Petya can cut the wooden bars into any parts, but each side of each door should be a solid piece of a wooden bar (or a whole wooden bar).
Input
The first line contains a single integer n (1 ≤ n ≤ 1 000) — the length of each wooden bar.
The second line contains a single integer a (1 ≤ a ≤ n) — the length of the vertical (left and right) sides of a door frame.
The third line contains a single integer b (1 ≤ b ≤ n) — the length of the upper side of a door frame.
Output
Print the minimal number of wooden bars with length n which are needed to make the frames for two doors.
Examples
Input
8
1
2
Output
1
Input
5
3
4
Output
6
Input
6
4
2
Output
4
Input
20
5
6
Output
2
Note
In the first example one wooden bar is enough, since the total length of all six sides of the frames for two doors is 8.
In the second example 6 wooden bars is enough, because for each side of the frames the new wooden bar is needed. | instruction | 0 | 12,244 | 8 | 24,488 |
Tags: greedy, implementation
Correct Solution:
```
# -*- coding: utf-8 -*-
"""
Created on Thu Nov 30 12:11:39 2017
@author: vishal
"""
n=int(input())
a=int(input())
b=int(input())
if(4*a+2*b<=n):
print(1)
elif(2*a+b<=n or a+2*b<=n and 3*a<=n):
print(2)
elif(a+b<=n and 2*a<=n or 2*b<=n and 2*a<=n or 4*a<=n):
print(3)
elif(2*a<=n or a+b<=n):
print(4)
elif(2*b<=n):
print(5)
else:
print(6)
``` | output | 1 | 12,244 | 8 | 24,489 |
Provide tags and a correct Python 3 solution for this coding contest problem.
Petya has equal wooden bars of length n. He wants to make a frame for two equal doors. Each frame has two vertical (left and right) sides of length a and one top side of length b. A solid (i.e. continuous without breaks) piece of bar is needed for each side.
Determine a minimal number of wooden bars which are needed to make the frames for two doors. Petya can cut the wooden bars into any parts, but each side of each door should be a solid piece of a wooden bar (or a whole wooden bar).
Input
The first line contains a single integer n (1 ≤ n ≤ 1 000) — the length of each wooden bar.
The second line contains a single integer a (1 ≤ a ≤ n) — the length of the vertical (left and right) sides of a door frame.
The third line contains a single integer b (1 ≤ b ≤ n) — the length of the upper side of a door frame.
Output
Print the minimal number of wooden bars with length n which are needed to make the frames for two doors.
Examples
Input
8
1
2
Output
1
Input
5
3
4
Output
6
Input
6
4
2
Output
4
Input
20
5
6
Output
2
Note
In the first example one wooden bar is enough, since the total length of all six sides of the frames for two doors is 8.
In the second example 6 wooden bars is enough, because for each side of the frames the new wooden bar is needed. | instruction | 0 | 12,245 | 8 | 24,490 |
Tags: greedy, implementation
Correct Solution:
```
n=int(input())
a=int(input())
b=int(input())
if a>=b:
l=a
s=b
if n-a>=3*l+2*b:
print(1)
if n-a<3*l+2*b and n-a>=a+b:
print(2)
if n-a<a+b and n-a>=a:
print(3)
if n-a<a and n-a>=b:
print(4)
if n-a<b and n-b>=b:
print(5)
if n-a<b and n-b<b:
print(6)
else:
l=b
s=a
if n-l>=1*l+4*s:
print(1)
if n-l<l+4*s and n-l>=2*s:
print(2)
if n-l<2*s and n-l>=s:
print(3)
if n-l<s and n>=4*s:
print(3)
if n-l<s and n>=2*s and n<4*s:
print(4)
if n-l<s and n-s<s:
print(6)
``` | output | 1 | 12,245 | 8 | 24,491 |
Provide tags and a correct Python 3 solution for this coding contest problem.
Petya has equal wooden bars of length n. He wants to make a frame for two equal doors. Each frame has two vertical (left and right) sides of length a and one top side of length b. A solid (i.e. continuous without breaks) piece of bar is needed for each side.
Determine a minimal number of wooden bars which are needed to make the frames for two doors. Petya can cut the wooden bars into any parts, but each side of each door should be a solid piece of a wooden bar (or a whole wooden bar).
Input
The first line contains a single integer n (1 ≤ n ≤ 1 000) — the length of each wooden bar.
The second line contains a single integer a (1 ≤ a ≤ n) — the length of the vertical (left and right) sides of a door frame.
The third line contains a single integer b (1 ≤ b ≤ n) — the length of the upper side of a door frame.
Output
Print the minimal number of wooden bars with length n which are needed to make the frames for two doors.
Examples
Input
8
1
2
Output
1
Input
5
3
4
Output
6
Input
6
4
2
Output
4
Input
20
5
6
Output
2
Note
In the first example one wooden bar is enough, since the total length of all six sides of the frames for two doors is 8.
In the second example 6 wooden bars is enough, because for each side of the frames the new wooden bar is needed. | instruction | 0 | 12,246 | 8 | 24,492 |
Tags: greedy, implementation
Correct Solution:
```
x=int(input())
a=int(input())
b=int(input())
ans=6
if a+b>x and 2*b<=x and 2*a>x:
ans=5
if (a+b<=x and 2*a>=x) or (2*b>x and 2*a<=x):
ans=4
if (2*a<=x and 2*b<=x) or (4*a<=x and 2*b>x) or (2*a<=x and a+b<=x):
ans=3
if 2*a+b<=x:
ans=2
if 4*a +2*b<=x:
ans=1
print(ans)
``` | output | 1 | 12,246 | 8 | 24,493 |
Provide tags and a correct Python 3 solution for this coding contest problem.
Petya has equal wooden bars of length n. He wants to make a frame for two equal doors. Each frame has two vertical (left and right) sides of length a and one top side of length b. A solid (i.e. continuous without breaks) piece of bar is needed for each side.
Determine a minimal number of wooden bars which are needed to make the frames for two doors. Petya can cut the wooden bars into any parts, but each side of each door should be a solid piece of a wooden bar (or a whole wooden bar).
Input
The first line contains a single integer n (1 ≤ n ≤ 1 000) — the length of each wooden bar.
The second line contains a single integer a (1 ≤ a ≤ n) — the length of the vertical (left and right) sides of a door frame.
The third line contains a single integer b (1 ≤ b ≤ n) — the length of the upper side of a door frame.
Output
Print the minimal number of wooden bars with length n which are needed to make the frames for two doors.
Examples
Input
8
1
2
Output
1
Input
5
3
4
Output
6
Input
6
4
2
Output
4
Input
20
5
6
Output
2
Note
In the first example one wooden bar is enough, since the total length of all six sides of the frames for two doors is 8.
In the second example 6 wooden bars is enough, because for each side of the frames the new wooden bar is needed. | instruction | 0 | 12,247 | 8 | 24,494 |
Tags: greedy, implementation
Correct Solution:
```
n = int(input())
a = int(input())
b = int(input())
na = 4
nb = 2
cnt=0
while True:
len = n
cnt+=1
while len>0:
resa = len-min(int(len/a),na)*a
resb = len-min(int(len/b),nb)*b
if resa<resb and na>0 and len>=a:
len-=a
na-=1
elif nb>0 and len>=b:
len-=b
nb-=1
else:
break
if na==nb==0:
break
print(cnt)
``` | output | 1 | 12,247 | 8 | 24,495 |
Provide tags and a correct Python 3 solution for this coding contest problem.
Petya has equal wooden bars of length n. He wants to make a frame for two equal doors. Each frame has two vertical (left and right) sides of length a and one top side of length b. A solid (i.e. continuous without breaks) piece of bar is needed for each side.
Determine a minimal number of wooden bars which are needed to make the frames for two doors. Petya can cut the wooden bars into any parts, but each side of each door should be a solid piece of a wooden bar (or a whole wooden bar).
Input
The first line contains a single integer n (1 ≤ n ≤ 1 000) — the length of each wooden bar.
The second line contains a single integer a (1 ≤ a ≤ n) — the length of the vertical (left and right) sides of a door frame.
The third line contains a single integer b (1 ≤ b ≤ n) — the length of the upper side of a door frame.
Output
Print the minimal number of wooden bars with length n which are needed to make the frames for two doors.
Examples
Input
8
1
2
Output
1
Input
5
3
4
Output
6
Input
6
4
2
Output
4
Input
20
5
6
Output
2
Note
In the first example one wooden bar is enough, since the total length of all six sides of the frames for two doors is 8.
In the second example 6 wooden bars is enough, because for each side of the frames the new wooden bar is needed. | instruction | 0 | 12,248 | 8 | 24,496 |
Tags: greedy, implementation
Correct Solution:
```
n = int(input())
a = int(input())
b = int(input())
if n >= 4 * a + 2 * b:
ans = 1
#print(1)
elif n >= 4 * a + b:
ans = 2
#print(2)
elif n >= 4 * a and 2 * b <= n:
ans = 2
#print(3)
elif n >= 3 * a + 2 * b:
ans = 2
#print(-7)
elif n >= 3 * a and n >= a + 2 * b:
ans = 2
#print(-6)
elif n >= 2 * a + b or n >= 2 * a + 2 * b:
ans = 2
#print(5)
elif n >= 2 * a and (n >= 2 * b or n >= a + b):
ans = 3
#else:####
# ans = 4
#print(6)
elif n >= a + 2 * b:######
ans = 4
#print(7)
elif n >= a + b:
ans = 4
#print(8)
elif n >= 2 * b:
if 3 * a <= n:
ans = 3
else:
ans = 5
#print(9)
else:
if 4 * a <= n:
ans = 3
elif 3 * a <= n:
ans = 4
elif 2 * a <= n:
ans = 4
else:
ans = 6
#print(10)
print(ans)
``` | output | 1 | 12,248 | 8 | 24,497 |
Provide tags and a correct Python 3 solution for this coding contest problem.
Petya has equal wooden bars of length n. He wants to make a frame for two equal doors. Each frame has two vertical (left and right) sides of length a and one top side of length b. A solid (i.e. continuous without breaks) piece of bar is needed for each side.
Determine a minimal number of wooden bars which are needed to make the frames for two doors. Petya can cut the wooden bars into any parts, but each side of each door should be a solid piece of a wooden bar (or a whole wooden bar).
Input
The first line contains a single integer n (1 ≤ n ≤ 1 000) — the length of each wooden bar.
The second line contains a single integer a (1 ≤ a ≤ n) — the length of the vertical (left and right) sides of a door frame.
The third line contains a single integer b (1 ≤ b ≤ n) — the length of the upper side of a door frame.
Output
Print the minimal number of wooden bars with length n which are needed to make the frames for two doors.
Examples
Input
8
1
2
Output
1
Input
5
3
4
Output
6
Input
6
4
2
Output
4
Input
20
5
6
Output
2
Note
In the first example one wooden bar is enough, since the total length of all six sides of the frames for two doors is 8.
In the second example 6 wooden bars is enough, because for each side of the frames the new wooden bar is needed. | instruction | 0 | 12,249 | 8 | 24,498 |
Tags: greedy, implementation
Correct Solution:
```
N,a,b=int(input()),int(input()),int(input())
queue=[(N,1,4,2)]
res=10000
while queue:
n,amount,x,y=queue.pop()
if x==0 and y==0:res=min(res,amount);continue
if x>0:
if n>=a:queue.append((n-a,amount,x-1,y))
else:queue.append((N-a,amount+1,x-1,y))
if y>0:
if n>=b:queue.append((n-b,amount,x,y-1))
else:queue.append((N-b,amount+1,x,y-1))
print(res)
``` | output | 1 | 12,249 | 8 | 24,499 |
Provide tags and a correct Python 3 solution for this coding contest problem.
Petya has equal wooden bars of length n. He wants to make a frame for two equal doors. Each frame has two vertical (left and right) sides of length a and one top side of length b. A solid (i.e. continuous without breaks) piece of bar is needed for each side.
Determine a minimal number of wooden bars which are needed to make the frames for two doors. Petya can cut the wooden bars into any parts, but each side of each door should be a solid piece of a wooden bar (or a whole wooden bar).
Input
The first line contains a single integer n (1 ≤ n ≤ 1 000) — the length of each wooden bar.
The second line contains a single integer a (1 ≤ a ≤ n) — the length of the vertical (left and right) sides of a door frame.
The third line contains a single integer b (1 ≤ b ≤ n) — the length of the upper side of a door frame.
Output
Print the minimal number of wooden bars with length n which are needed to make the frames for two doors.
Examples
Input
8
1
2
Output
1
Input
5
3
4
Output
6
Input
6
4
2
Output
4
Input
20
5
6
Output
2
Note
In the first example one wooden bar is enough, since the total length of all six sides of the frames for two doors is 8.
In the second example 6 wooden bars is enough, because for each side of the frames the new wooden bar is needed. | instruction | 0 | 12,250 | 8 | 24,500 |
Tags: greedy, implementation
Correct Solution:
```
import sys
#needed: 4 a, 2b
n = int(sys.stdin.readline().strip())
am = int(sys.stdin.readline().strip())
bm = int(sys.stdin.readline().strip())
def recurse(a, b):
global n
#print("foo", a, b)
pairs = set()
if(a <= 0 and b <= 0):
return 0;
for i in range(0, a + 1):
for j in range(0, b + 1):
pairs.add((i, j))
woods = 1
answer = float("inf")
for (i, j) in pairs:
if(n >= (am * i + bm * j) and (am * i + bm * j) is not 0):
rec = recurse(a - i, b - j)
#print(n, (am * i + bm * j), rec)
answer = min(answer, rec)
return woods + answer
print(recurse(4, 2))
``` | output | 1 | 12,250 | 8 | 24,501 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
Petya has equal wooden bars of length n. He wants to make a frame for two equal doors. Each frame has two vertical (left and right) sides of length a and one top side of length b. A solid (i.e. continuous without breaks) piece of bar is needed for each side.
Determine a minimal number of wooden bars which are needed to make the frames for two doors. Petya can cut the wooden bars into any parts, but each side of each door should be a solid piece of a wooden bar (or a whole wooden bar).
Input
The first line contains a single integer n (1 ≤ n ≤ 1 000) — the length of each wooden bar.
The second line contains a single integer a (1 ≤ a ≤ n) — the length of the vertical (left and right) sides of a door frame.
The third line contains a single integer b (1 ≤ b ≤ n) — the length of the upper side of a door frame.
Output
Print the minimal number of wooden bars with length n which are needed to make the frames for two doors.
Examples
Input
8
1
2
Output
1
Input
5
3
4
Output
6
Input
6
4
2
Output
4
Input
20
5
6
Output
2
Note
In the first example one wooden bar is enough, since the total length of all six sides of the frames for two doors is 8.
In the second example 6 wooden bars is enough, because for each side of the frames the new wooden bar is needed.
Submitted Solution:
```
import math
[n,a,b],r,i,j=[int(input())for x in range(3)],6,4,5
while i>=0:
l,c,o=[b if x in[i,j]else a for x in range(6)],0,n
for k in l:
if o<k:
o,c=n-k,c+1
else:o-=k
r=min(r,c if o==n else c+1)
j-=1
if i==j:i,j=i-1,5
print(r)
# Made By Mostafa_Khaled
``` | instruction | 0 | 12,251 | 8 | 24,502 |
Yes | output | 1 | 12,251 | 8 | 24,503 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
Petya has equal wooden bars of length n. He wants to make a frame for two equal doors. Each frame has two vertical (left and right) sides of length a and one top side of length b. A solid (i.e. continuous without breaks) piece of bar is needed for each side.
Determine a minimal number of wooden bars which are needed to make the frames for two doors. Petya can cut the wooden bars into any parts, but each side of each door should be a solid piece of a wooden bar (or a whole wooden bar).
Input
The first line contains a single integer n (1 ≤ n ≤ 1 000) — the length of each wooden bar.
The second line contains a single integer a (1 ≤ a ≤ n) — the length of the vertical (left and right) sides of a door frame.
The third line contains a single integer b (1 ≤ b ≤ n) — the length of the upper side of a door frame.
Output
Print the minimal number of wooden bars with length n which are needed to make the frames for two doors.
Examples
Input
8
1
2
Output
1
Input
5
3
4
Output
6
Input
6
4
2
Output
4
Input
20
5
6
Output
2
Note
In the first example one wooden bar is enough, since the total length of all six sides of the frames for two doors is 8.
In the second example 6 wooden bars is enough, because for each side of the frames the new wooden bar is needed.
Submitted Solution:
```
n = int(input())
a = int(input())
b = int(input())
ax, bx = 4, 2
x = 0
z = False
if a*2+b < n//2:
print(1)
elif a*2+b == n:
print(2)
elif a >= b:
while ax >= 0 and bx >= 0:
if ax == bx == 0:
print(x)
exit()
for i in range(ax, -1, -1):
for j in range(bx, -1, -1):
# print(i ,j)
if (a*i)+(b*j) <= n:
# print('yes')
ax -= i
bx -= j
x += 1
z = True
break
if z:
z = not z
break
else:
while ax >= 0 and bx >= 0:
if ax == bx == 0:
print(x)
exit()
for i in range(bx, -1, -1):
for j in range(ax, -1, -1):
# print(i ,j)
if (a*j)+(b*i) <= n:
# print('yes')
ax -= j
bx -= i
x += 1
z = True
break
if z:
z = not z
break
``` | instruction | 0 | 12,252 | 8 | 24,504 |
Yes | output | 1 | 12,252 | 8 | 24,505 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
Petya has equal wooden bars of length n. He wants to make a frame for two equal doors. Each frame has two vertical (left and right) sides of length a and one top side of length b. A solid (i.e. continuous without breaks) piece of bar is needed for each side.
Determine a minimal number of wooden bars which are needed to make the frames for two doors. Petya can cut the wooden bars into any parts, but each side of each door should be a solid piece of a wooden bar (or a whole wooden bar).
Input
The first line contains a single integer n (1 ≤ n ≤ 1 000) — the length of each wooden bar.
The second line contains a single integer a (1 ≤ a ≤ n) — the length of the vertical (left and right) sides of a door frame.
The third line contains a single integer b (1 ≤ b ≤ n) — the length of the upper side of a door frame.
Output
Print the minimal number of wooden bars with length n which are needed to make the frames for two doors.
Examples
Input
8
1
2
Output
1
Input
5
3
4
Output
6
Input
6
4
2
Output
4
Input
20
5
6
Output
2
Note
In the first example one wooden bar is enough, since the total length of all six sides of the frames for two doors is 8.
In the second example 6 wooden bars is enough, because for each side of the frames the new wooden bar is needed.
Submitted Solution:
```
'''input
6
4
2
'''
def list_input():
return list(map(int,input().split()))
def map_input():
return map(int,input().split())
def map_string():
return input().split()
def f(n,a,b,left,cnta = 4,cntb = 2):
if(cnta == 0 and cntb == 0): return 0
if(cnta < 0 or cntb < 0): return 100000000000000000000
if a <= left and cnta and b <= left and cntb:
return min(f(n,a,b,left-a,cnta-1,cntb),f(n,a,b,left-b,cnta,cntb-1))
if a <= left and cnta:
return f(n,a,b,left-a,cnta-1,cntb)
if b <= left and cntb:
return f(n,a,b,left-b,cnta,cntb-1)
return 1+min(f(n,a,b,n-a,cnta-1,cntb),f(n,a,b,n-b,cnta,cntb-1))
n = int(input())
a = int(input())
b = int(input())
print(f(n,a,b,0))
``` | instruction | 0 | 12,253 | 8 | 24,506 |
Yes | output | 1 | 12,253 | 8 | 24,507 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
Petya has equal wooden bars of length n. He wants to make a frame for two equal doors. Each frame has two vertical (left and right) sides of length a and one top side of length b. A solid (i.e. continuous without breaks) piece of bar is needed for each side.
Determine a minimal number of wooden bars which are needed to make the frames for two doors. Petya can cut the wooden bars into any parts, but each side of each door should be a solid piece of a wooden bar (or a whole wooden bar).
Input
The first line contains a single integer n (1 ≤ n ≤ 1 000) — the length of each wooden bar.
The second line contains a single integer a (1 ≤ a ≤ n) — the length of the vertical (left and right) sides of a door frame.
The third line contains a single integer b (1 ≤ b ≤ n) — the length of the upper side of a door frame.
Output
Print the minimal number of wooden bars with length n which are needed to make the frames for two doors.
Examples
Input
8
1
2
Output
1
Input
5
3
4
Output
6
Input
6
4
2
Output
4
Input
20
5
6
Output
2
Note
In the first example one wooden bar is enough, since the total length of all six sides of the frames for two doors is 8.
In the second example 6 wooden bars is enough, because for each side of the frames the new wooden bar is needed.
Submitted Solution:
```
#from dust i have come dust i will be
n=int(input())
a=int(input())
b=int(input())
cnt=1
r=n
qa,qb=0,0
while 1:
if r>=a and qa<4:
r-=a
qa+=1
if r>=b and qb<2:
r-=b
qb+=1
if qa==4 and qb==2:
print(cnt)
exit(0)
if (r<a or qa==4) and (r<b or qb==2):
r=n
cnt+=1
``` | instruction | 0 | 12,254 | 8 | 24,508 |
Yes | output | 1 | 12,254 | 8 | 24,509 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
Petya has equal wooden bars of length n. He wants to make a frame for two equal doors. Each frame has two vertical (left and right) sides of length a and one top side of length b. A solid (i.e. continuous without breaks) piece of bar is needed for each side.
Determine a minimal number of wooden bars which are needed to make the frames for two doors. Petya can cut the wooden bars into any parts, but each side of each door should be a solid piece of a wooden bar (or a whole wooden bar).
Input
The first line contains a single integer n (1 ≤ n ≤ 1 000) — the length of each wooden bar.
The second line contains a single integer a (1 ≤ a ≤ n) — the length of the vertical (left and right) sides of a door frame.
The third line contains a single integer b (1 ≤ b ≤ n) — the length of the upper side of a door frame.
Output
Print the minimal number of wooden bars with length n which are needed to make the frames for two doors.
Examples
Input
8
1
2
Output
1
Input
5
3
4
Output
6
Input
6
4
2
Output
4
Input
20
5
6
Output
2
Note
In the first example one wooden bar is enough, since the total length of all six sides of the frames for two doors is 8.
In the second example 6 wooden bars is enough, because for each side of the frames the new wooden bar is needed.
Submitted Solution:
```
#!/usr/bin/env python3
# -*- coding: utf-8 -*-
def main():
n = int(input())
a = int(input())
b = int(input())
for i in range(1, 7):
left = [a, a, b, a, a, b]
left.sort(reverse=True)
for _ in range(i):
if not left:
break
sz = n
while sz >= left[0]:
sz -= left[0]
left.pop(0)
if not left:
break
if not left:
break
while sz >= left[-1]:
sz -= left[-1]
left.pop()
if not left:
print(i)
exit()
if __name__ == '__main__':
main()
``` | instruction | 0 | 12,255 | 8 | 24,510 |
No | output | 1 | 12,255 | 8 | 24,511 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
Petya has equal wooden bars of length n. He wants to make a frame for two equal doors. Each frame has two vertical (left and right) sides of length a and one top side of length b. A solid (i.e. continuous without breaks) piece of bar is needed for each side.
Determine a minimal number of wooden bars which are needed to make the frames for two doors. Petya can cut the wooden bars into any parts, but each side of each door should be a solid piece of a wooden bar (or a whole wooden bar).
Input
The first line contains a single integer n (1 ≤ n ≤ 1 000) — the length of each wooden bar.
The second line contains a single integer a (1 ≤ a ≤ n) — the length of the vertical (left and right) sides of a door frame.
The third line contains a single integer b (1 ≤ b ≤ n) — the length of the upper side of a door frame.
Output
Print the minimal number of wooden bars with length n which are needed to make the frames for two doors.
Examples
Input
8
1
2
Output
1
Input
5
3
4
Output
6
Input
6
4
2
Output
4
Input
20
5
6
Output
2
Note
In the first example one wooden bar is enough, since the total length of all six sides of the frames for two doors is 8.
In the second example 6 wooden bars is enough, because for each side of the frames the new wooden bar is needed.
Submitted Solution:
```
n = int(input())
a = int(input())
b = int(input())
cnt = 0
lenth = 0
cnt = 0
max_num = max(a,b)
min_num = min(a,b)
if max_num == a:
max_cnt = 4
min_cnt = 2
else:
max_cnt = 2
min_cnt = 4
rand_num = min_num
for i in range(6):
if max_cnt == 0 and min_cnt == 0:
break
if lenth < rand_num:
lenth = n
if lenth % (2*a + b) == 0:
cnt = 2
break
cnt += 1
if lenth >= max_num and max_cnt > 0:
lenth -= max_num
max_cnt -= 1
elif lenth >= min_num and min_cnt > 0:
lenth -= min_num
min_cnt -= 1
if min_cnt == 0:
rand_num = max_num
print(cnt)
``` | instruction | 0 | 12,256 | 8 | 24,512 |
No | output | 1 | 12,256 | 8 | 24,513 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
Petya has equal wooden bars of length n. He wants to make a frame for two equal doors. Each frame has two vertical (left and right) sides of length a and one top side of length b. A solid (i.e. continuous without breaks) piece of bar is needed for each side.
Determine a minimal number of wooden bars which are needed to make the frames for two doors. Petya can cut the wooden bars into any parts, but each side of each door should be a solid piece of a wooden bar (or a whole wooden bar).
Input
The first line contains a single integer n (1 ≤ n ≤ 1 000) — the length of each wooden bar.
The second line contains a single integer a (1 ≤ a ≤ n) — the length of the vertical (left and right) sides of a door frame.
The third line contains a single integer b (1 ≤ b ≤ n) — the length of the upper side of a door frame.
Output
Print the minimal number of wooden bars with length n which are needed to make the frames for two doors.
Examples
Input
8
1
2
Output
1
Input
5
3
4
Output
6
Input
6
4
2
Output
4
Input
20
5
6
Output
2
Note
In the first example one wooden bar is enough, since the total length of all six sides of the frames for two doors is 8.
In the second example 6 wooden bars is enough, because for each side of the frames the new wooden bar is needed.
Submitted Solution:
```
from math import floor
n = int(input())
a = int(input())
b = int(input())
if 4 * a + 2 * b <= n:
print(1)
exit(0)
if 2 * a + b <= n:
print(2)
exit(0)
if 4 * a <= n:
print(3)
exit(0)
if 2 * b <= n:
if a + 2 * b <= n:
if n // a >= 3:
print(2)
exit(0)
elif n // a == 2:
print(3)
exit(0)
else:
print(4)
exit(0)
else:
if n // a >= 4:
print(2)
exit(0)
elif n // a == 3:
print(3)
exit(0)
elif n // a == 2:
print(4)
exit(0)
if a + b <= n:
print(4)
exit(0)
print(6)
``` | instruction | 0 | 12,257 | 8 | 24,514 |
No | output | 1 | 12,257 | 8 | 24,515 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
Petya has equal wooden bars of length n. He wants to make a frame for two equal doors. Each frame has two vertical (left and right) sides of length a and one top side of length b. A solid (i.e. continuous without breaks) piece of bar is needed for each side.
Determine a minimal number of wooden bars which are needed to make the frames for two doors. Petya can cut the wooden bars into any parts, but each side of each door should be a solid piece of a wooden bar (or a whole wooden bar).
Input
The first line contains a single integer n (1 ≤ n ≤ 1 000) — the length of each wooden bar.
The second line contains a single integer a (1 ≤ a ≤ n) — the length of the vertical (left and right) sides of a door frame.
The third line contains a single integer b (1 ≤ b ≤ n) — the length of the upper side of a door frame.
Output
Print the minimal number of wooden bars with length n which are needed to make the frames for two doors.
Examples
Input
8
1
2
Output
1
Input
5
3
4
Output
6
Input
6
4
2
Output
4
Input
20
5
6
Output
2
Note
In the first example one wooden bar is enough, since the total length of all six sides of the frames for two doors is 8.
In the second example 6 wooden bars is enough, because for each side of the frames the new wooden bar is needed.
Submitted Solution:
```
n=int(input())
a=int(input())
b=int(input())
ma=max(a,b)
mi=min(a,b)
L=[]
if mi==a:
L.append(mi)
L.append(mi)
L.append(mi)
L.append(mi)
elif mi==b:
L.append(mi)
L.append(mi)
if ma==a:
L.append(ma)
L.append(ma)
L.append(ma)
L.append(ma)
elif ma==b:
L.append(ma)
L.append(ma)
ini=n
count=1
start=0
for i in L:
if i<=n:
n-=i
if start==1:
count+=1
else:
count+=1
n=ini
start=1
print(count)
``` | instruction | 0 | 12,258 | 8 | 24,516 |
No | output | 1 | 12,258 | 8 | 24,517 |
Provide tags and a correct Python 3 solution for this coding contest problem.
Emuskald is an avid horticulturist and owns the world's longest greenhouse — it is effectively infinite in length.
Over the years Emuskald has cultivated n plants in his greenhouse, of m different plant species numbered from 1 to m. His greenhouse is very narrow and can be viewed as an infinite line, with each plant occupying a single point on that line.
Emuskald has discovered that each species thrives at a different temperature, so he wants to arrange m - 1 borders that would divide the greenhouse into m sections numbered from 1 to m from left to right with each section housing a single species. He is free to place the borders, but in the end all of the i-th species plants must reside in i-th section from the left.
Of course, it is not always possible to place the borders in such way, so Emuskald needs to replant some of his plants. He can remove each plant from its position and place it anywhere in the greenhouse (at any real coordinate) with no plant already in it. Since replanting is a lot of stress for the plants, help Emuskald find the minimum number of plants he has to replant to be able to place the borders.
Input
The first line of input contains two space-separated integers n and m (1 ≤ n, m ≤ 5000, n ≥ m), the number of plants and the number of different species. Each of the following n lines contain two space-separated numbers: one integer number si (1 ≤ si ≤ m), and one real number xi (0 ≤ xi ≤ 109), the species and position of the i-th plant. Each xi will contain no more than 6 digits after the decimal point.
It is guaranteed that all xi are different; there is at least one plant of each species; the plants are given in order "from left to the right", that is in the ascending order of their xi coordinates (xi < xi + 1, 1 ≤ i < n).
Output
Output a single integer — the minimum number of plants to be replanted.
Examples
Input
3 2
2 1
1 2.0
1 3.100
Output
1
Input
3 3
1 5.0
2 5.5
3 6.0
Output
0
Input
6 3
1 14.284235
2 17.921382
1 20.328172
3 20.842331
1 25.790145
1 27.204125
Output
2
Note
In the first test case, Emuskald can replant the first plant to the right of the last plant, so the answer is 1.
In the second test case, the species are already in the correct order, so no replanting is needed. | instruction | 0 | 12,748 | 8 | 25,496 |
Tags: dp
Correct Solution:
```
from math import ceil,sqrt
from collections import defaultdict
def solve():
n,m = map(int,input().split())
l = []
for i in range(n):
a,b = map(float,input().split())
l.append(a)
dp = [0]*(n)
for i in range(n):
maxi = 0
for j in range(i):
if l[i]>=l[j]:
maxi = max(dp[j],maxi)
dp[i] = maxi+1
# print(dp)
print(n-max(dp))
# t = int(input())
# for _ in range(t):
solve()
``` | output | 1 | 12,748 | 8 | 25,497 |
Provide tags and a correct Python 3 solution for this coding contest problem.
Emuskald is an avid horticulturist and owns the world's longest greenhouse — it is effectively infinite in length.
Over the years Emuskald has cultivated n plants in his greenhouse, of m different plant species numbered from 1 to m. His greenhouse is very narrow and can be viewed as an infinite line, with each plant occupying a single point on that line.
Emuskald has discovered that each species thrives at a different temperature, so he wants to arrange m - 1 borders that would divide the greenhouse into m sections numbered from 1 to m from left to right with each section housing a single species. He is free to place the borders, but in the end all of the i-th species plants must reside in i-th section from the left.
Of course, it is not always possible to place the borders in such way, so Emuskald needs to replant some of his plants. He can remove each plant from its position and place it anywhere in the greenhouse (at any real coordinate) with no plant already in it. Since replanting is a lot of stress for the plants, help Emuskald find the minimum number of plants he has to replant to be able to place the borders.
Input
The first line of input contains two space-separated integers n and m (1 ≤ n, m ≤ 5000, n ≥ m), the number of plants and the number of different species. Each of the following n lines contain two space-separated numbers: one integer number si (1 ≤ si ≤ m), and one real number xi (0 ≤ xi ≤ 109), the species and position of the i-th plant. Each xi will contain no more than 6 digits after the decimal point.
It is guaranteed that all xi are different; there is at least one plant of each species; the plants are given in order "from left to the right", that is in the ascending order of their xi coordinates (xi < xi + 1, 1 ≤ i < n).
Output
Output a single integer — the minimum number of plants to be replanted.
Examples
Input
3 2
2 1
1 2.0
1 3.100
Output
1
Input
3 3
1 5.0
2 5.5
3 6.0
Output
0
Input
6 3
1 14.284235
2 17.921382
1 20.328172
3 20.842331
1 25.790145
1 27.204125
Output
2
Note
In the first test case, Emuskald can replant the first plant to the right of the last plant, so the answer is 1.
In the second test case, the species are already in the correct order, so no replanting is needed. | instruction | 0 | 12,749 | 8 | 25,498 |
Tags: dp
Correct Solution:
```
# Dynamic programming Python implementation
# of LIS problem
# lis returns length of the longest
# increasing subsequence in arr of size n
def lis(l, arr):
# Declare the list (array) for LIS and
# initialize LIS values for all indexes
ls = [1] * l
# Compute optimized LIS values in bottom up manner
for i in range(1, l):
for j in range(0, i):
if arr[i] >= arr[j] and ls[i] < ls[j] + 1:
ls[i] = ls[j] + 1
# print(ls)
return l - max(ls)
# end of lis function
n, m = map(int, input().split())
lst = []
for i in range(n):
a, b = map(float, input().split())
lst.append(a)
print(lis(n, lst))
``` | output | 1 | 12,749 | 8 | 25,499 |
Provide tags and a correct Python 3 solution for this coding contest problem.
Emuskald is an avid horticulturist and owns the world's longest greenhouse — it is effectively infinite in length.
Over the years Emuskald has cultivated n plants in his greenhouse, of m different plant species numbered from 1 to m. His greenhouse is very narrow and can be viewed as an infinite line, with each plant occupying a single point on that line.
Emuskald has discovered that each species thrives at a different temperature, so he wants to arrange m - 1 borders that would divide the greenhouse into m sections numbered from 1 to m from left to right with each section housing a single species. He is free to place the borders, but in the end all of the i-th species plants must reside in i-th section from the left.
Of course, it is not always possible to place the borders in such way, so Emuskald needs to replant some of his plants. He can remove each plant from its position and place it anywhere in the greenhouse (at any real coordinate) with no plant already in it. Since replanting is a lot of stress for the plants, help Emuskald find the minimum number of plants he has to replant to be able to place the borders.
Input
The first line of input contains two space-separated integers n and m (1 ≤ n, m ≤ 5000, n ≥ m), the number of plants and the number of different species. Each of the following n lines contain two space-separated numbers: one integer number si (1 ≤ si ≤ m), and one real number xi (0 ≤ xi ≤ 109), the species and position of the i-th plant. Each xi will contain no more than 6 digits after the decimal point.
It is guaranteed that all xi are different; there is at least one plant of each species; the plants are given in order "from left to the right", that is in the ascending order of their xi coordinates (xi < xi + 1, 1 ≤ i < n).
Output
Output a single integer — the minimum number of plants to be replanted.
Examples
Input
3 2
2 1
1 2.0
1 3.100
Output
1
Input
3 3
1 5.0
2 5.5
3 6.0
Output
0
Input
6 3
1 14.284235
2 17.921382
1 20.328172
3 20.842331
1 25.790145
1 27.204125
Output
2
Note
In the first test case, Emuskald can replant the first plant to the right of the last plant, so the answer is 1.
In the second test case, the species are already in the correct order, so no replanting is needed. | instruction | 0 | 12,750 | 8 | 25,500 |
Tags: dp
Correct Solution:
```
def f(arr):
arr=[None]+arr
dp=[0]*(len(arr))
for i in range(1,len(arr)):
j=int(arr[i])
for k in range(int(j),0,-1):
dp[j]=max(dp[j],1+dp[k])
return len(arr)-max(dp)-1
# Dynamic programming Python implementation
# of LIS problem
# lis returns length of the longest
# increasing subsequence in arr of size n
def lis(arr):
n = len(arr)
# Declare the list (array) for LIS and
# initialize LIS values for all indexes
lis = [1]*n
# Compute optimized LIS values in bottom up manner
for i in range (1 , n):
for j in range(0 , i):
if arr[i] >= arr[j] and lis[i]< lis[j] + 1 :
lis[i] = lis[j]+1
# Initialize maximum to 0 to get
# the maximum of all LIS
return max(len(lst)-max(lis),0)
a,b=map(int,input().strip().split())
lst=[]
for i in range(a):
x,y=map(float,input().strip().split())
lst.append(x)
print(lis(lst))
``` | output | 1 | 12,750 | 8 | 25,501 |
Provide tags and a correct Python 3 solution for this coding contest problem.
Emuskald is an avid horticulturist and owns the world's longest greenhouse — it is effectively infinite in length.
Over the years Emuskald has cultivated n plants in his greenhouse, of m different plant species numbered from 1 to m. His greenhouse is very narrow and can be viewed as an infinite line, with each plant occupying a single point on that line.
Emuskald has discovered that each species thrives at a different temperature, so he wants to arrange m - 1 borders that would divide the greenhouse into m sections numbered from 1 to m from left to right with each section housing a single species. He is free to place the borders, but in the end all of the i-th species plants must reside in i-th section from the left.
Of course, it is not always possible to place the borders in such way, so Emuskald needs to replant some of his plants. He can remove each plant from its position and place it anywhere in the greenhouse (at any real coordinate) with no plant already in it. Since replanting is a lot of stress for the plants, help Emuskald find the minimum number of plants he has to replant to be able to place the borders.
Input
The first line of input contains two space-separated integers n and m (1 ≤ n, m ≤ 5000, n ≥ m), the number of plants and the number of different species. Each of the following n lines contain two space-separated numbers: one integer number si (1 ≤ si ≤ m), and one real number xi (0 ≤ xi ≤ 109), the species and position of the i-th plant. Each xi will contain no more than 6 digits after the decimal point.
It is guaranteed that all xi are different; there is at least one plant of each species; the plants are given in order "from left to the right", that is in the ascending order of their xi coordinates (xi < xi + 1, 1 ≤ i < n).
Output
Output a single integer — the minimum number of plants to be replanted.
Examples
Input
3 2
2 1
1 2.0
1 3.100
Output
1
Input
3 3
1 5.0
2 5.5
3 6.0
Output
0
Input
6 3
1 14.284235
2 17.921382
1 20.328172
3 20.842331
1 25.790145
1 27.204125
Output
2
Note
In the first test case, Emuskald can replant the first plant to the right of the last plant, so the answer is 1.
In the second test case, the species are already in the correct order, so no replanting is needed. | instruction | 0 | 12,751 | 8 | 25,502 |
Tags: dp
Correct Solution:
```
def lis(arr):
n = len(arr)
# Declare the list (array) for LIS and
# initialize LIS values for all indexes
lis = [1]*n
# Compute optimized LIS values in bottom up manner
for i in range (1 , n):
for j in range(0 , i):
if arr[i] >= arr[j] and lis[i]< lis[j] + 1 :
lis[i] = lis[j]+1
# Initialize maximum to 0 to get
# the maximum of all LIS
return max(len(lst)-max(lis),0)
a,b=map(int,input().strip().split())
lst=[]
for i in range(a):
x,y=map(float,input().strip().split())
lst.append(x)
print(lis(lst))
``` | output | 1 | 12,751 | 8 | 25,503 |
Provide tags and a correct Python 3 solution for this coding contest problem.
Emuskald is an avid horticulturist and owns the world's longest greenhouse — it is effectively infinite in length.
Over the years Emuskald has cultivated n plants in his greenhouse, of m different plant species numbered from 1 to m. His greenhouse is very narrow and can be viewed as an infinite line, with each plant occupying a single point on that line.
Emuskald has discovered that each species thrives at a different temperature, so he wants to arrange m - 1 borders that would divide the greenhouse into m sections numbered from 1 to m from left to right with each section housing a single species. He is free to place the borders, but in the end all of the i-th species plants must reside in i-th section from the left.
Of course, it is not always possible to place the borders in such way, so Emuskald needs to replant some of his plants. He can remove each plant from its position and place it anywhere in the greenhouse (at any real coordinate) with no plant already in it. Since replanting is a lot of stress for the plants, help Emuskald find the minimum number of plants he has to replant to be able to place the borders.
Input
The first line of input contains two space-separated integers n and m (1 ≤ n, m ≤ 5000, n ≥ m), the number of plants and the number of different species. Each of the following n lines contain two space-separated numbers: one integer number si (1 ≤ si ≤ m), and one real number xi (0 ≤ xi ≤ 109), the species and position of the i-th plant. Each xi will contain no more than 6 digits after the decimal point.
It is guaranteed that all xi are different; there is at least one plant of each species; the plants are given in order "from left to the right", that is in the ascending order of their xi coordinates (xi < xi + 1, 1 ≤ i < n).
Output
Output a single integer — the minimum number of plants to be replanted.
Examples
Input
3 2
2 1
1 2.0
1 3.100
Output
1
Input
3 3
1 5.0
2 5.5
3 6.0
Output
0
Input
6 3
1 14.284235
2 17.921382
1 20.328172
3 20.842331
1 25.790145
1 27.204125
Output
2
Note
In the first test case, Emuskald can replant the first plant to the right of the last plant, so the answer is 1.
In the second test case, the species are already in the correct order, so no replanting is needed. | instruction | 0 | 12,752 | 8 | 25,504 |
Tags: dp
Correct Solution:
```
n,m = list(map(int,input().split()))
arr = []
for i in range(n):
l = list(map(float,input().split()))
arr.append(int(l[0]))
dp = [1 for i in range(n)]
for i in range(1,n):
for j in range(i):
if arr[j]<=arr[i]:
dp[i] = max(dp[i],dp[j]+1)
print(n-max(dp))
``` | output | 1 | 12,752 | 8 | 25,505 |
Provide tags and a correct Python 3 solution for this coding contest problem.
Emuskald is an avid horticulturist and owns the world's longest greenhouse — it is effectively infinite in length.
Over the years Emuskald has cultivated n plants in his greenhouse, of m different plant species numbered from 1 to m. His greenhouse is very narrow and can be viewed as an infinite line, with each plant occupying a single point on that line.
Emuskald has discovered that each species thrives at a different temperature, so he wants to arrange m - 1 borders that would divide the greenhouse into m sections numbered from 1 to m from left to right with each section housing a single species. He is free to place the borders, but in the end all of the i-th species plants must reside in i-th section from the left.
Of course, it is not always possible to place the borders in such way, so Emuskald needs to replant some of his plants. He can remove each plant from its position and place it anywhere in the greenhouse (at any real coordinate) with no plant already in it. Since replanting is a lot of stress for the plants, help Emuskald find the minimum number of plants he has to replant to be able to place the borders.
Input
The first line of input contains two space-separated integers n and m (1 ≤ n, m ≤ 5000, n ≥ m), the number of plants and the number of different species. Each of the following n lines contain two space-separated numbers: one integer number si (1 ≤ si ≤ m), and one real number xi (0 ≤ xi ≤ 109), the species and position of the i-th plant. Each xi will contain no more than 6 digits after the decimal point.
It is guaranteed that all xi are different; there is at least one plant of each species; the plants are given in order "from left to the right", that is in the ascending order of their xi coordinates (xi < xi + 1, 1 ≤ i < n).
Output
Output a single integer — the minimum number of plants to be replanted.
Examples
Input
3 2
2 1
1 2.0
1 3.100
Output
1
Input
3 3
1 5.0
2 5.5
3 6.0
Output
0
Input
6 3
1 14.284235
2 17.921382
1 20.328172
3 20.842331
1 25.790145
1 27.204125
Output
2
Note
In the first test case, Emuskald can replant the first plant to the right of the last plant, so the answer is 1.
In the second test case, the species are already in the correct order, so no replanting is needed. | instruction | 0 | 12,753 | 8 | 25,506 |
Tags: dp
Correct Solution:
```
n, m = [int(x) for x in input().split()]
d = [0 for i in range(m)]
for i in range(n):
c, x = [x for x in input().split()]
c = int(c)
d[c-1] = max(d[:c])+1
print(n-max(d))
``` | output | 1 | 12,753 | 8 | 25,507 |
Provide tags and a correct Python 3 solution for this coding contest problem.
Emuskald is an avid horticulturist and owns the world's longest greenhouse — it is effectively infinite in length.
Over the years Emuskald has cultivated n plants in his greenhouse, of m different plant species numbered from 1 to m. His greenhouse is very narrow and can be viewed as an infinite line, with each plant occupying a single point on that line.
Emuskald has discovered that each species thrives at a different temperature, so he wants to arrange m - 1 borders that would divide the greenhouse into m sections numbered from 1 to m from left to right with each section housing a single species. He is free to place the borders, but in the end all of the i-th species plants must reside in i-th section from the left.
Of course, it is not always possible to place the borders in such way, so Emuskald needs to replant some of his plants. He can remove each plant from its position and place it anywhere in the greenhouse (at any real coordinate) with no plant already in it. Since replanting is a lot of stress for the plants, help Emuskald find the minimum number of plants he has to replant to be able to place the borders.
Input
The first line of input contains two space-separated integers n and m (1 ≤ n, m ≤ 5000, n ≥ m), the number of plants and the number of different species. Each of the following n lines contain two space-separated numbers: one integer number si (1 ≤ si ≤ m), and one real number xi (0 ≤ xi ≤ 109), the species and position of the i-th plant. Each xi will contain no more than 6 digits after the decimal point.
It is guaranteed that all xi are different; there is at least one plant of each species; the plants are given in order "from left to the right", that is in the ascending order of their xi coordinates (xi < xi + 1, 1 ≤ i < n).
Output
Output a single integer — the minimum number of plants to be replanted.
Examples
Input
3 2
2 1
1 2.0
1 3.100
Output
1
Input
3 3
1 5.0
2 5.5
3 6.0
Output
0
Input
6 3
1 14.284235
2 17.921382
1 20.328172
3 20.842331
1 25.790145
1 27.204125
Output
2
Note
In the first test case, Emuskald can replant the first plant to the right of the last plant, so the answer is 1.
In the second test case, the species are already in the correct order, so no replanting is needed. | instruction | 0 | 12,754 | 8 | 25,508 |
Tags: dp
Correct Solution:
```
n,m=map(int,input().split())
l=[]
for i in range(n):
a,b=input().split()
l.append(int(a))
dp=[1]*n
for i in range(1,n):
for j in range(0,i):
if l[i]>=l[j]:
dp[i]=max(dp[i],dp[j]+1)
print(n-max(dp))
``` | output | 1 | 12,754 | 8 | 25,509 |
Provide tags and a correct Python 3 solution for this coding contest problem.
Emuskald is an avid horticulturist and owns the world's longest greenhouse — it is effectively infinite in length.
Over the years Emuskald has cultivated n plants in his greenhouse, of m different plant species numbered from 1 to m. His greenhouse is very narrow and can be viewed as an infinite line, with each plant occupying a single point on that line.
Emuskald has discovered that each species thrives at a different temperature, so he wants to arrange m - 1 borders that would divide the greenhouse into m sections numbered from 1 to m from left to right with each section housing a single species. He is free to place the borders, but in the end all of the i-th species plants must reside in i-th section from the left.
Of course, it is not always possible to place the borders in such way, so Emuskald needs to replant some of his plants. He can remove each plant from its position and place it anywhere in the greenhouse (at any real coordinate) with no plant already in it. Since replanting is a lot of stress for the plants, help Emuskald find the minimum number of plants he has to replant to be able to place the borders.
Input
The first line of input contains two space-separated integers n and m (1 ≤ n, m ≤ 5000, n ≥ m), the number of plants and the number of different species. Each of the following n lines contain two space-separated numbers: one integer number si (1 ≤ si ≤ m), and one real number xi (0 ≤ xi ≤ 109), the species and position of the i-th plant. Each xi will contain no more than 6 digits after the decimal point.
It is guaranteed that all xi are different; there is at least one plant of each species; the plants are given in order "from left to the right", that is in the ascending order of their xi coordinates (xi < xi + 1, 1 ≤ i < n).
Output
Output a single integer — the minimum number of plants to be replanted.
Examples
Input
3 2
2 1
1 2.0
1 3.100
Output
1
Input
3 3
1 5.0
2 5.5
3 6.0
Output
0
Input
6 3
1 14.284235
2 17.921382
1 20.328172
3 20.842331
1 25.790145
1 27.204125
Output
2
Note
In the first test case, Emuskald can replant the first plant to the right of the last plant, so the answer is 1.
In the second test case, the species are already in the correct order, so no replanting is needed. | instruction | 0 | 12,755 | 8 | 25,510 |
Tags: dp
Correct Solution:
```
# -*- coding:utf-8 -*-
"""
created by shuangquan.huang at 1/10/20
LIS
"""
import collections
import time
import os
import sys
import bisect
import heapq
from typing import List
def solve(N, M, A):
bit = [0 for _ in range(N)]
def add(index, val):
while index < N:
bit[index] = max(bit[index], val)
index |= index + 1
def query(index):
s = 0
while index >= 0:
s = max(s, bit[index])
index = (index & (index + 1)) - 1
return s
q = [(v, i) for i, v in enumerate(A)]
q.sort()
s = 0
for v, i in q:
t = query(i) + 1
add(i, t)
s = max(s, t)
return N-s
N, M = map(int, input().split())
A = []
for i in range(N):
x, y = input().split()
A.append(int(x))
print(solve(N, M, A))
``` | output | 1 | 12,755 | 8 | 25,511 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
Emuskald is an avid horticulturist and owns the world's longest greenhouse — it is effectively infinite in length.
Over the years Emuskald has cultivated n plants in his greenhouse, of m different plant species numbered from 1 to m. His greenhouse is very narrow and can be viewed as an infinite line, with each plant occupying a single point on that line.
Emuskald has discovered that each species thrives at a different temperature, so he wants to arrange m - 1 borders that would divide the greenhouse into m sections numbered from 1 to m from left to right with each section housing a single species. He is free to place the borders, but in the end all of the i-th species plants must reside in i-th section from the left.
Of course, it is not always possible to place the borders in such way, so Emuskald needs to replant some of his plants. He can remove each plant from its position and place it anywhere in the greenhouse (at any real coordinate) with no plant already in it. Since replanting is a lot of stress for the plants, help Emuskald find the minimum number of plants he has to replant to be able to place the borders.
Input
The first line of input contains two space-separated integers n and m (1 ≤ n, m ≤ 5000, n ≥ m), the number of plants and the number of different species. Each of the following n lines contain two space-separated numbers: one integer number si (1 ≤ si ≤ m), and one real number xi (0 ≤ xi ≤ 109), the species and position of the i-th plant. Each xi will contain no more than 6 digits after the decimal point.
It is guaranteed that all xi are different; there is at least one plant of each species; the plants are given in order "from left to the right", that is in the ascending order of their xi coordinates (xi < xi + 1, 1 ≤ i < n).
Output
Output a single integer — the minimum number of plants to be replanted.
Examples
Input
3 2
2 1
1 2.0
1 3.100
Output
1
Input
3 3
1 5.0
2 5.5
3 6.0
Output
0
Input
6 3
1 14.284235
2 17.921382
1 20.328172
3 20.842331
1 25.790145
1 27.204125
Output
2
Note
In the first test case, Emuskald can replant the first plant to the right of the last plant, so the answer is 1.
In the second test case, the species are already in the correct order, so no replanting is needed.
Submitted Solution:
```
'''n, m, k = [int(x) for x in input().split()]
trees = tuple([int(x) for x in input().split()])
costs = []
for x in range(n):
costs.append([0] + [int(x) for x in input().split()])
dp = [[[float('inf') for z in range(m + 1)] for y in range(k + 1)] for x in range(n)]
if trees[0] == 0:
for k in range(len(dp[0][0])):
dp[0][1][k] = cost[0][k]
else:
dp[0][0][trees[0]] = cost[0][trees[0]]
for i in range(1, len(dp)):
for j in range(1, len(dp[0])):
for k in range(1, len(dp[0][0])):
if trees
for l in range(len(dp[0][0])):
if k == l:
dp[i][j][k] = dp[i - 1][j][k] + cost[i][k]
else:
dp[i][j][k] = dp[i - 1][j - 1][l] + cost[i][k]'''
n, m = [int(x) for x in input().split()]
plant = [int(input().split()[0]) for x in range(n)]
dp = [1 for x in range(n)]
for i in range(len(plant)):
for j in range(0, i):
if plant[j] > plant[i]:
continue
dp[i] = max(dp[i], dp[j] + 1)
#print(dp)
print(n - max(dp))
'''for i in range(1, n):
for k in range(plant[i], 0, -1):
dp[plant[i]] = max(dp[plant[i]], 1 + dp[k])
print(n - max(dp) - 1)'''
``` | instruction | 0 | 12,756 | 8 | 25,512 |
Yes | output | 1 | 12,756 | 8 | 25,513 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
Emuskald is an avid horticulturist and owns the world's longest greenhouse — it is effectively infinite in length.
Over the years Emuskald has cultivated n plants in his greenhouse, of m different plant species numbered from 1 to m. His greenhouse is very narrow and can be viewed as an infinite line, with each plant occupying a single point on that line.
Emuskald has discovered that each species thrives at a different temperature, so he wants to arrange m - 1 borders that would divide the greenhouse into m sections numbered from 1 to m from left to right with each section housing a single species. He is free to place the borders, but in the end all of the i-th species plants must reside in i-th section from the left.
Of course, it is not always possible to place the borders in such way, so Emuskald needs to replant some of his plants. He can remove each plant from its position and place it anywhere in the greenhouse (at any real coordinate) with no plant already in it. Since replanting is a lot of stress for the plants, help Emuskald find the minimum number of plants he has to replant to be able to place the borders.
Input
The first line of input contains two space-separated integers n and m (1 ≤ n, m ≤ 5000, n ≥ m), the number of plants and the number of different species. Each of the following n lines contain two space-separated numbers: one integer number si (1 ≤ si ≤ m), and one real number xi (0 ≤ xi ≤ 109), the species and position of the i-th plant. Each xi will contain no more than 6 digits after the decimal point.
It is guaranteed that all xi are different; there is at least one plant of each species; the plants are given in order "from left to the right", that is in the ascending order of their xi coordinates (xi < xi + 1, 1 ≤ i < n).
Output
Output a single integer — the minimum number of plants to be replanted.
Examples
Input
3 2
2 1
1 2.0
1 3.100
Output
1
Input
3 3
1 5.0
2 5.5
3 6.0
Output
0
Input
6 3
1 14.284235
2 17.921382
1 20.328172
3 20.842331
1 25.790145
1 27.204125
Output
2
Note
In the first test case, Emuskald can replant the first plant to the right of the last plant, so the answer is 1.
In the second test case, the species are already in the correct order, so no replanting is needed.
Submitted Solution:
```
"""
Code of Ayush Tiwari
Codeforces: servermonk
Codechef: ayush572000
"""
import sys
input = sys.stdin.buffer.readline
def solution():
# This is the main code
n,m=map(int,input().split())
l=[]
dp=[1]*(n+1)
for i in range(n):
x,y=map(float,input().split())
l.append([x,y])
for i in range(1,n):
for j in range(i):
if(l[i][0]>=l[j][0]):
dp[i]=max(dp[i],dp[j]+1)
print(n-max(dp))
t=1
for _ in range(t):
solution()
``` | instruction | 0 | 12,757 | 8 | 25,514 |
Yes | output | 1 | 12,757 | 8 | 25,515 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
Emuskald is an avid horticulturist and owns the world's longest greenhouse — it is effectively infinite in length.
Over the years Emuskald has cultivated n plants in his greenhouse, of m different plant species numbered from 1 to m. His greenhouse is very narrow and can be viewed as an infinite line, with each plant occupying a single point on that line.
Emuskald has discovered that each species thrives at a different temperature, so he wants to arrange m - 1 borders that would divide the greenhouse into m sections numbered from 1 to m from left to right with each section housing a single species. He is free to place the borders, but in the end all of the i-th species plants must reside in i-th section from the left.
Of course, it is not always possible to place the borders in such way, so Emuskald needs to replant some of his plants. He can remove each plant from its position and place it anywhere in the greenhouse (at any real coordinate) with no plant already in it. Since replanting is a lot of stress for the plants, help Emuskald find the minimum number of plants he has to replant to be able to place the borders.
Input
The first line of input contains two space-separated integers n and m (1 ≤ n, m ≤ 5000, n ≥ m), the number of plants and the number of different species. Each of the following n lines contain two space-separated numbers: one integer number si (1 ≤ si ≤ m), and one real number xi (0 ≤ xi ≤ 109), the species and position of the i-th plant. Each xi will contain no more than 6 digits after the decimal point.
It is guaranteed that all xi are different; there is at least one plant of each species; the plants are given in order "from left to the right", that is in the ascending order of their xi coordinates (xi < xi + 1, 1 ≤ i < n).
Output
Output a single integer — the minimum number of plants to be replanted.
Examples
Input
3 2
2 1
1 2.0
1 3.100
Output
1
Input
3 3
1 5.0
2 5.5
3 6.0
Output
0
Input
6 3
1 14.284235
2 17.921382
1 20.328172
3 20.842331
1 25.790145
1 27.204125
Output
2
Note
In the first test case, Emuskald can replant the first plant to the right of the last plant, so the answer is 1.
In the second test case, the species are already in the correct order, so no replanting is needed.
Submitted Solution:
```
from sys import stdin
n,m=map(int,input().split())
s=[list(map(float,stdin.readline().strip().split()))[::-1] for i in range(n)]
s.sort()
s1=[int(i[1]) for i in s]
dp=[1 for i in range(n)]
ans=1
for i in range(n-2,-1,-1):
for j in range(i+1,n):
if s1[j]>=s1[i]:
dp[i]=max(dp[i],1+dp[j])
ans=max(dp[i],ans)
print(n-ans)
``` | instruction | 0 | 12,758 | 8 | 25,516 |
Yes | output | 1 | 12,758 | 8 | 25,517 |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.