message stringlengths 2 22.7k | message_type stringclasses 2 values | message_id int64 0 1 | conversation_id int64 145 109k | cluster float64 9 9 | __index_level_0__ int64 290 217k |
|---|---|---|---|---|---|
Provide a correct Python 3 solution for this coding contest problem.
Does the card fit in a snack? (Are Cards Snacks?)
square1001 You have $ N $ cards.
Each of these cards has an integer written on it, and the integer on the $ i $ th card is $ A_i $.
square1001 Your random number today is $ K $. square1001 You want to choose some of these $ N $ cards so that they add up to $ K $.
E869120, who was watching this situation, wanted to prevent this.
Specifically, I want to eat a few cards in advance so that square1001 doesn't add up to $ K $ no matter how you choose the rest of the cards.
However, E869120 is full and I don't want to eat cards as much as possible.
Now, how many cards can you eat at least E869120 to prevent this?
input
Input is given from standard input in the following format.
$ N $ $ K $
$ A_1 $ $ A_2 $ $ A_3 $ $ \ cdots $ $ A_N $
output
E869120 Print the minimum number of cards you eat to achieve your goal in one line.
However, insert a line break at the end.
Constraint
* $ 1 \ leq N \ leq 20 $
* $ 1 \ leq K \ leq 1000000000 \ (= 10 ^ 9) $
* $ 0 \ leq A_i \ leq 1000000 \ (= 10 ^ 6) $
* All inputs are integers.
Input example 1
5 9
8 6 9 1 2
Output example 1
2
For example, you can thwart square1001's purpose by eating the third card (which has a 9) and the fourth card (which has a 1).
Input example 2
8 2
1 1 1 1 1 1 1 1
Output example 2
7
Input example 3
20 200
31 12 21 17 19 29 25 40 5 8 32 1 27 20 31 13 35 1 8 5
Output example 3
6
Example
Input
5 9
8 6 9 1 2
Output
2 | instruction | 0 | 34,224 | 9 | 68,448 |
"Correct Solution:
```
from itertools import *
from bisect import *
from math import *
from collections import *
from heapq import *
from random import *
from decimal import *
import sys
sys.setrecursionlimit(10 ** 6)
int1 = lambda x: int(x) - 1
p2D = lambda x: print(*x, sep="\n")
def II(): return int(sys.stdin.readline())
def MI(): return map(int, sys.stdin.readline().split())
def MI1(): return map(int1, sys.stdin.readline().split())
def MF(): return map(float, sys.stdin.readline().split())
def LI(): return list(map(int, sys.stdin.readline().split()))
def LI1(): return list(map(int1, sys.stdin.readline().split()))
def LF(): return list(map(float, sys.stdin.readline().split()))
def LLI(rows_number): return [LI() for _ in range(rows_number)]
dij = [(1, 0), (0, 1), (-1, 0), (0, -1)]
def main():
n,k=MI()
aa=LI()
bek=[False]*(1<<n)
for bit in range(1<<n):
if bek[bit]==False:
s=sum(a for i,a in enumerate(aa) if bit>>i&1)
if s==k:bek[bit]=True
else:continue
for j in range(n):
bek[bit|1<<j]=True
mx=0
for bit in range(1<<n):
if bek[bit]:continue
popcnt=bin(bit).count("1")
if popcnt>mx:mx=popcnt
print(n-mx)
main()
``` | output | 1 | 34,224 | 9 | 68,449 |
Provide tags and a correct Python 3 solution for this coding contest problem.
Karafs is some kind of vegetable in shape of an 1 × h rectangle. Tavaspolis people love Karafs and they use Karafs in almost any kind of food. Tavas, himself, is crazy about Karafs.
<image>
Each Karafs has a positive integer height. Tavas has an infinite 1-based sequence of Karafses. The height of the i-th Karafs is si = A + (i - 1) × B.
For a given m, let's define an m-bite operation as decreasing the height of at most m distinct not eaten Karafses by 1. Karafs is considered as eaten when its height becomes zero.
Now SaDDas asks you n queries. In each query he gives you numbers l, t and m and you should find the largest number r such that l ≤ r and sequence sl, sl + 1, ..., sr can be eaten by performing m-bite no more than t times or print -1 if there is no such number r.
Input
The first line of input contains three integers A, B and n (1 ≤ A, B ≤ 106, 1 ≤ n ≤ 105).
Next n lines contain information about queries. i-th line contains integers l, t, m (1 ≤ l, t, m ≤ 106) for i-th query.
Output
For each query, print its answer in a single line.
Examples
Input
2 1 4
1 5 3
3 3 10
7 10 2
6 4 8
Output
4
-1
8
-1
Input
1 5 2
1 5 10
2 7 4
Output
1
2 | instruction | 0 | 34,697 | 9 | 69,394 |
Tags: binary search, greedy, math
Correct Solution:
```
f = lambda: map(int, input().split())
A, B, n = f()
for i in range(n):
l, t, m = f()
S = 2 * (A + B * l) - B
T = S - B - 2 * m * t
r = l + int(((S * S - 4 * B * T) ** 0.5 - S) / (2 * B))
r = min(r, (t - A) // B + 1)
print(-1 if r < l else r)
``` | output | 1 | 34,697 | 9 | 69,395 |
Provide tags and a correct Python 3 solution for this coding contest problem.
Karafs is some kind of vegetable in shape of an 1 × h rectangle. Tavaspolis people love Karafs and they use Karafs in almost any kind of food. Tavas, himself, is crazy about Karafs.
<image>
Each Karafs has a positive integer height. Tavas has an infinite 1-based sequence of Karafses. The height of the i-th Karafs is si = A + (i - 1) × B.
For a given m, let's define an m-bite operation as decreasing the height of at most m distinct not eaten Karafses by 1. Karafs is considered as eaten when its height becomes zero.
Now SaDDas asks you n queries. In each query he gives you numbers l, t and m and you should find the largest number r such that l ≤ r and sequence sl, sl + 1, ..., sr can be eaten by performing m-bite no more than t times or print -1 if there is no such number r.
Input
The first line of input contains three integers A, B and n (1 ≤ A, B ≤ 106, 1 ≤ n ≤ 105).
Next n lines contain information about queries. i-th line contains integers l, t, m (1 ≤ l, t, m ≤ 106) for i-th query.
Output
For each query, print its answer in a single line.
Examples
Input
2 1 4
1 5 3
3 3 10
7 10 2
6 4 8
Output
4
-1
8
-1
Input
1 5 2
1 5 10
2 7 4
Output
1
2 | instruction | 0 | 34,698 | 9 | 69,396 |
Tags: binary search, greedy, math
Correct Solution:
```
# -*- coding: utf-8 -*-
"""
Created on Wed Apr 15 01:59:52 2015
codeforces 299 Div 2 C
"""
import sys
def read_data():
A, B, n = map(int, input().split())
ltm = sys.stdin.readlines()
return A, B, ltm
def solve(A, B, ltm):
for line in ltm:
L, t, m = map(int, line.split())
print(max_r(L, t, m, A, B))
memo = dict()
def max_r(L, t, m, A, B):
global memo
if (L, t, m) in memo:
return memo[L, t, m]
r_upper = (t - A) // B + 2
if r_upper <= L:
memo[L, t, m] = -1
return -1
r_lower = L
threshold = t * m
while r_upper > r_lower + 1:
mid = (r_upper + r_lower) // 2
if (2 * A + B * (L + mid - 2)) * (mid - L + 1) // 2 <= threshold:
r_lower = mid
else:
r_upper = mid
memo[L, t, m] = r_lower
return r_lower
A, B, ltm = read_data()
solve(A, B, ltm)
``` | output | 1 | 34,698 | 9 | 69,397 |
Provide tags and a correct Python 3 solution for this coding contest problem.
Karafs is some kind of vegetable in shape of an 1 × h rectangle. Tavaspolis people love Karafs and they use Karafs in almost any kind of food. Tavas, himself, is crazy about Karafs.
<image>
Each Karafs has a positive integer height. Tavas has an infinite 1-based sequence of Karafses. The height of the i-th Karafs is si = A + (i - 1) × B.
For a given m, let's define an m-bite operation as decreasing the height of at most m distinct not eaten Karafses by 1. Karafs is considered as eaten when its height becomes zero.
Now SaDDas asks you n queries. In each query he gives you numbers l, t and m and you should find the largest number r such that l ≤ r and sequence sl, sl + 1, ..., sr can be eaten by performing m-bite no more than t times or print -1 if there is no such number r.
Input
The first line of input contains three integers A, B and n (1 ≤ A, B ≤ 106, 1 ≤ n ≤ 105).
Next n lines contain information about queries. i-th line contains integers l, t, m (1 ≤ l, t, m ≤ 106) for i-th query.
Output
For each query, print its answer in a single line.
Examples
Input
2 1 4
1 5 3
3 3 10
7 10 2
6 4 8
Output
4
-1
8
-1
Input
1 5 2
1 5 10
2 7 4
Output
1
2 | instruction | 0 | 34,699 | 9 | 69,398 |
Tags: binary search, greedy, math
Correct Solution:
```
import math
a,b,n =[int(x) for x in input().split()]
for i in range(n):
l,t,m=[int(x) for x in input().split()]
x=a+(l-1)*b
if x>t:
print("-1")
continue
r=(t-a)//b+1
D=(2*x-b)**2+8*m*t*b
d=int(math.floor((-2*x+b+math.sqrt(D))/(2*b)))
print(min(r,l+d-1))
'''
//////////////// ////// /////// // /////// // // //
//// // /// /// /// /// // /// /// //// //
//// //// /// /// /// /// // ///////// //// ///////
//// ///// /// /// /// /// // /// /// //// // //
////////////// /////////// /////////// ////// /// /// // // // //
'''
``` | output | 1 | 34,699 | 9 | 69,399 |
Provide tags and a correct Python 3 solution for this coding contest problem.
Karafs is some kind of vegetable in shape of an 1 × h rectangle. Tavaspolis people love Karafs and they use Karafs in almost any kind of food. Tavas, himself, is crazy about Karafs.
<image>
Each Karafs has a positive integer height. Tavas has an infinite 1-based sequence of Karafses. The height of the i-th Karafs is si = A + (i - 1) × B.
For a given m, let's define an m-bite operation as decreasing the height of at most m distinct not eaten Karafses by 1. Karafs is considered as eaten when its height becomes zero.
Now SaDDas asks you n queries. In each query he gives you numbers l, t and m and you should find the largest number r such that l ≤ r and sequence sl, sl + 1, ..., sr can be eaten by performing m-bite no more than t times or print -1 if there is no such number r.
Input
The first line of input contains three integers A, B and n (1 ≤ A, B ≤ 106, 1 ≤ n ≤ 105).
Next n lines contain information about queries. i-th line contains integers l, t, m (1 ≤ l, t, m ≤ 106) for i-th query.
Output
For each query, print its answer in a single line.
Examples
Input
2 1 4
1 5 3
3 3 10
7 10 2
6 4 8
Output
4
-1
8
-1
Input
1 5 2
1 5 10
2 7 4
Output
1
2 | instruction | 0 | 34,700 | 9 | 69,400 |
Tags: binary search, greedy, math
Correct Solution:
```
a,b,n = map(int,input().split())
lis=[0]+[(a+ i*b) for i in range(1000001)]
for i in range(n):
ll,t,m = map(int,input().split())
l=ll
r=(t-a)//b+1
while l<=r:
mid = l+(r-l)//2
ter = mid-ll+1
su = ((ter)*(2*lis[ll] + (ter-1)*b))//2
if t*m>=su and lis[mid]<=t:
l=mid+1
else:
r=mid-1
# print(l,r)
if l==ll:
print(-1)
else:
print(r)
``` | output | 1 | 34,700 | 9 | 69,401 |
Provide tags and a correct Python 3 solution for this coding contest problem.
Karafs is some kind of vegetable in shape of an 1 × h rectangle. Tavaspolis people love Karafs and they use Karafs in almost any kind of food. Tavas, himself, is crazy about Karafs.
<image>
Each Karafs has a positive integer height. Tavas has an infinite 1-based sequence of Karafses. The height of the i-th Karafs is si = A + (i - 1) × B.
For a given m, let's define an m-bite operation as decreasing the height of at most m distinct not eaten Karafses by 1. Karafs is considered as eaten when its height becomes zero.
Now SaDDas asks you n queries. In each query he gives you numbers l, t and m and you should find the largest number r such that l ≤ r and sequence sl, sl + 1, ..., sr can be eaten by performing m-bite no more than t times or print -1 if there is no such number r.
Input
The first line of input contains three integers A, B and n (1 ≤ A, B ≤ 106, 1 ≤ n ≤ 105).
Next n lines contain information about queries. i-th line contains integers l, t, m (1 ≤ l, t, m ≤ 106) for i-th query.
Output
For each query, print its answer in a single line.
Examples
Input
2 1 4
1 5 3
3 3 10
7 10 2
6 4 8
Output
4
-1
8
-1
Input
1 5 2
1 5 10
2 7 4
Output
1
2 | instruction | 0 | 34,701 | 9 | 69,402 |
Tags: binary search, greedy, math
Correct Solution:
```
f = lambda: map(int, input().split())
A, B, n = f()
k = 0.5
for i in range(n):
l, t, m = f()
b = A / B + l - k
c = b - k - (m * t) / B
r = min(l + int((b * b - 2 * c) ** k - b), (t - A) // B + 1)
print(-1 if r < l else r)
# Made By Mostafa_Khaled
``` | output | 1 | 34,701 | 9 | 69,403 |
Provide tags and a correct Python 3 solution for this coding contest problem.
Karafs is some kind of vegetable in shape of an 1 × h rectangle. Tavaspolis people love Karafs and they use Karafs in almost any kind of food. Tavas, himself, is crazy about Karafs.
<image>
Each Karafs has a positive integer height. Tavas has an infinite 1-based sequence of Karafses. The height of the i-th Karafs is si = A + (i - 1) × B.
For a given m, let's define an m-bite operation as decreasing the height of at most m distinct not eaten Karafses by 1. Karafs is considered as eaten when its height becomes zero.
Now SaDDas asks you n queries. In each query he gives you numbers l, t and m and you should find the largest number r such that l ≤ r and sequence sl, sl + 1, ..., sr can be eaten by performing m-bite no more than t times or print -1 if there is no such number r.
Input
The first line of input contains three integers A, B and n (1 ≤ A, B ≤ 106, 1 ≤ n ≤ 105).
Next n lines contain information about queries. i-th line contains integers l, t, m (1 ≤ l, t, m ≤ 106) for i-th query.
Output
For each query, print its answer in a single line.
Examples
Input
2 1 4
1 5 3
3 3 10
7 10 2
6 4 8
Output
4
-1
8
-1
Input
1 5 2
1 5 10
2 7 4
Output
1
2 | instruction | 0 | 34,702 | 9 | 69,404 |
Tags: binary search, greedy, math
Correct Solution:
```
a,b,n=[int(x) for x in input().split()]
ltm=[[]]*n
for i in range(n):
ltm[i]=[int(x) for x in input().split()]
for i in range(n):
l,t,m=ltm[i]
maxr=(t-a)//b+1
minr=l
while maxr>=minr:
r=(maxr+minr)//2
if t*m>=(r-l+1)*(2*a+b*(r+l-2))/2:
minr=r+1
else:
maxr=r-1
r=maxr
if r<l:
print(-1)
else:
print(r)
``` | output | 1 | 34,702 | 9 | 69,405 |
Provide tags and a correct Python 3 solution for this coding contest problem.
Karafs is some kind of vegetable in shape of an 1 × h rectangle. Tavaspolis people love Karafs and they use Karafs in almost any kind of food. Tavas, himself, is crazy about Karafs.
<image>
Each Karafs has a positive integer height. Tavas has an infinite 1-based sequence of Karafses. The height of the i-th Karafs is si = A + (i - 1) × B.
For a given m, let's define an m-bite operation as decreasing the height of at most m distinct not eaten Karafses by 1. Karafs is considered as eaten when its height becomes zero.
Now SaDDas asks you n queries. In each query he gives you numbers l, t and m and you should find the largest number r such that l ≤ r and sequence sl, sl + 1, ..., sr can be eaten by performing m-bite no more than t times or print -1 if there is no such number r.
Input
The first line of input contains three integers A, B and n (1 ≤ A, B ≤ 106, 1 ≤ n ≤ 105).
Next n lines contain information about queries. i-th line contains integers l, t, m (1 ≤ l, t, m ≤ 106) for i-th query.
Output
For each query, print its answer in a single line.
Examples
Input
2 1 4
1 5 3
3 3 10
7 10 2
6 4 8
Output
4
-1
8
-1
Input
1 5 2
1 5 10
2 7 4
Output
1
2 | instruction | 0 | 34,703 | 9 | 69,406 |
Tags: binary search, greedy, math
Correct Solution:
```
import sys
import math
a, b, n = map(int, str.split(sys.stdin.readline()))
s = lambda i: a + (i - 1) * b
S = lambda i: a * i + b * i * (i - 1) // 2
for _ in range(n):
l, t, m = map(int, str.split(sys.stdin.readline()))
# Si = a * r + b * r * (r - 1) / 2
# Si = b / 2 * r ^ 2 - (b / 2 - a) * r
# si = a + (i - 1) * b => (si - a) / b + 1 = i
# (S(r) - S(l-1)) / t <= m
# S(r) <= m * t + S(l-1)
# b / 2 * r ^ 2 - (b / 2 - a) * r - m * t - S(l-1) <= 0
# D = (b / 2 - a) ^ 2 + 4 * b / 2 * (m * t + S(l-1))
d = (b / 2 - a) ** 2 + 4 * b / 2 * (m * t + S(l - 1))
if d < 0:
print(-1)
continue
r = min(
math.floor((t - a) / b + 1),
math.floor(((b / 2 - a) + math.sqrt(d)) / b)
)
if r < l:
print(-1)
else:
print(r)
``` | output | 1 | 34,703 | 9 | 69,407 |
Provide tags and a correct Python 3 solution for this coding contest problem.
Karafs is some kind of vegetable in shape of an 1 × h rectangle. Tavaspolis people love Karafs and they use Karafs in almost any kind of food. Tavas, himself, is crazy about Karafs.
<image>
Each Karafs has a positive integer height. Tavas has an infinite 1-based sequence of Karafses. The height of the i-th Karafs is si = A + (i - 1) × B.
For a given m, let's define an m-bite operation as decreasing the height of at most m distinct not eaten Karafses by 1. Karafs is considered as eaten when its height becomes zero.
Now SaDDas asks you n queries. In each query he gives you numbers l, t and m and you should find the largest number r such that l ≤ r and sequence sl, sl + 1, ..., sr can be eaten by performing m-bite no more than t times or print -1 if there is no such number r.
Input
The first line of input contains three integers A, B and n (1 ≤ A, B ≤ 106, 1 ≤ n ≤ 105).
Next n lines contain information about queries. i-th line contains integers l, t, m (1 ≤ l, t, m ≤ 106) for i-th query.
Output
For each query, print its answer in a single line.
Examples
Input
2 1 4
1 5 3
3 3 10
7 10 2
6 4 8
Output
4
-1
8
-1
Input
1 5 2
1 5 10
2 7 4
Output
1
2 | instruction | 0 | 34,704 | 9 | 69,408 |
Tags: binary search, greedy, math
Correct Solution:
```
f = lambda: map(int, input().split())
A, B, n = f()
k = 0.5
for i in range(n):
l, t, m = f()
b = A / B + l - k
c = b - k - (m * t) / B
r = min(l + int((b * b - 2 * c) ** k - b), (t - A) // B + 1)
print(-1 if r < l else r)
``` | output | 1 | 34,704 | 9 | 69,409 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
Karafs is some kind of vegetable in shape of an 1 × h rectangle. Tavaspolis people love Karafs and they use Karafs in almost any kind of food. Tavas, himself, is crazy about Karafs.
<image>
Each Karafs has a positive integer height. Tavas has an infinite 1-based sequence of Karafses. The height of the i-th Karafs is si = A + (i - 1) × B.
For a given m, let's define an m-bite operation as decreasing the height of at most m distinct not eaten Karafses by 1. Karafs is considered as eaten when its height becomes zero.
Now SaDDas asks you n queries. In each query he gives you numbers l, t and m and you should find the largest number r such that l ≤ r and sequence sl, sl + 1, ..., sr can be eaten by performing m-bite no more than t times or print -1 if there is no such number r.
Input
The first line of input contains three integers A, B and n (1 ≤ A, B ≤ 106, 1 ≤ n ≤ 105).
Next n lines contain information about queries. i-th line contains integers l, t, m (1 ≤ l, t, m ≤ 106) for i-th query.
Output
For each query, print its answer in a single line.
Examples
Input
2 1 4
1 5 3
3 3 10
7 10 2
6 4 8
Output
4
-1
8
-1
Input
1 5 2
1 5 10
2 7 4
Output
1
2
Submitted Solution:
```
import math
a, b, n = [int(x) for x in input().split()]
for i in range(n):
l, t, m = [int(x) for x in input().split()]
x = a + (l - 1) * b
if x > t:
print("-1")
continue
r = (t - a) // b + 1
D = (2 * x - b) ** 2 + 8 * m * t * b
d = int(math.floor((-2 * x + b + math.sqrt(D)) / (2 * b)))
r = min(r, l + d - 1)
print(r)
``` | instruction | 0 | 34,705 | 9 | 69,410 |
Yes | output | 1 | 34,705 | 9 | 69,411 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
Karafs is some kind of vegetable in shape of an 1 × h rectangle. Tavaspolis people love Karafs and they use Karafs in almost any kind of food. Tavas, himself, is crazy about Karafs.
<image>
Each Karafs has a positive integer height. Tavas has an infinite 1-based sequence of Karafses. The height of the i-th Karafs is si = A + (i - 1) × B.
For a given m, let's define an m-bite operation as decreasing the height of at most m distinct not eaten Karafses by 1. Karafs is considered as eaten when its height becomes zero.
Now SaDDas asks you n queries. In each query he gives you numbers l, t and m and you should find the largest number r such that l ≤ r and sequence sl, sl + 1, ..., sr can be eaten by performing m-bite no more than t times or print -1 if there is no such number r.
Input
The first line of input contains three integers A, B and n (1 ≤ A, B ≤ 106, 1 ≤ n ≤ 105).
Next n lines contain information about queries. i-th line contains integers l, t, m (1 ≤ l, t, m ≤ 106) for i-th query.
Output
For each query, print its answer in a single line.
Examples
Input
2 1 4
1 5 3
3 3 10
7 10 2
6 4 8
Output
4
-1
8
-1
Input
1 5 2
1 5 10
2 7 4
Output
1
2
Submitted Solution:
```
import sys
input = sys.stdin.readline
a, b, n, l, t, m = -1, -1, -1, -1, -1, -1
def is_valid(mid):
biggest = a + (mid - 1) * b;
if t < biggest:
return False
sum = ((mid - l + 1) * (a + (l - 1) * b + biggest)) // 2
return t >= biggest and m * t >= sum
def binary_search(b, e):
while b <= e:
mid = b + e >> 1
if is_valid(mid):
b = mid + 1
else:
e = mid - 1
return b - 1
a, b, n = map(int, input().split())
for _ in range(n):
l, t, m = map(int, input().split())
res = binary_search(l, l + int(1e6))
print(-1 if res == l - 1 else res)
``` | instruction | 0 | 34,706 | 9 | 69,412 |
Yes | output | 1 | 34,706 | 9 | 69,413 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
Karafs is some kind of vegetable in shape of an 1 × h rectangle. Tavaspolis people love Karafs and they use Karafs in almost any kind of food. Tavas, himself, is crazy about Karafs.
<image>
Each Karafs has a positive integer height. Tavas has an infinite 1-based sequence of Karafses. The height of the i-th Karafs is si = A + (i - 1) × B.
For a given m, let's define an m-bite operation as decreasing the height of at most m distinct not eaten Karafses by 1. Karafs is considered as eaten when its height becomes zero.
Now SaDDas asks you n queries. In each query he gives you numbers l, t and m and you should find the largest number r such that l ≤ r and sequence sl, sl + 1, ..., sr can be eaten by performing m-bite no more than t times or print -1 if there is no such number r.
Input
The first line of input contains three integers A, B and n (1 ≤ A, B ≤ 106, 1 ≤ n ≤ 105).
Next n lines contain information about queries. i-th line contains integers l, t, m (1 ≤ l, t, m ≤ 106) for i-th query.
Output
For each query, print its answer in a single line.
Examples
Input
2 1 4
1 5 3
3 3 10
7 10 2
6 4 8
Output
4
-1
8
-1
Input
1 5 2
1 5 10
2 7 4
Output
1
2
Submitted Solution:
```
R = lambda: map(int, input().split())
a, b, n = R()
for _ in range(n):
l, t, m = R()
ll, rr = l - 1, 10**6 + 7
sl = a + (l - 1) * b
while ll < rr:
mm = (ll + rr + 1) // 2
sr = a + (mm - 1) * b
slr = (sl + sr) * (mm - l + 1) // 2
if slr <= t * m and sr <= t:
ll = mm
else:
rr = mm - 1
if ll >= l:
print(ll)
else:
print(-1)
``` | instruction | 0 | 34,707 | 9 | 69,414 |
Yes | output | 1 | 34,707 | 9 | 69,415 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
Karafs is some kind of vegetable in shape of an 1 × h rectangle. Tavaspolis people love Karafs and they use Karafs in almost any kind of food. Tavas, himself, is crazy about Karafs.
<image>
Each Karafs has a positive integer height. Tavas has an infinite 1-based sequence of Karafses. The height of the i-th Karafs is si = A + (i - 1) × B.
For a given m, let's define an m-bite operation as decreasing the height of at most m distinct not eaten Karafses by 1. Karafs is considered as eaten when its height becomes zero.
Now SaDDas asks you n queries. In each query he gives you numbers l, t and m and you should find the largest number r such that l ≤ r and sequence sl, sl + 1, ..., sr can be eaten by performing m-bite no more than t times or print -1 if there is no such number r.
Input
The first line of input contains three integers A, B and n (1 ≤ A, B ≤ 106, 1 ≤ n ≤ 105).
Next n lines contain information about queries. i-th line contains integers l, t, m (1 ≤ l, t, m ≤ 106) for i-th query.
Output
For each query, print its answer in a single line.
Examples
Input
2 1 4
1 5 3
3 3 10
7 10 2
6 4 8
Output
4
-1
8
-1
Input
1 5 2
1 5 10
2 7 4
Output
1
2
Submitted Solution:
```
a,b,n=map(int,input().split())
for _ in range(n):
l,t,m=map(int,input().split())
lo=l
hi=100000000
while lo<hi:
mid=(lo+hi)//2
count=(mid-l)+1
first=a+(l-1)*b
last=a+(mid-1)*b
if last<=t and (count*(first+last))//2<=m*t:
lo=mid+1
else:
hi=mid
if mid!=lo:
print(mid)
else:
count=(mid-1-l)+1
first=a+(l-1)*b
last=a+(mid-1-1)*b
if last<=t and (count*(first+last))//2<=m*t and mid-1>=l:
print(mid-1)
else:
print(-1)
``` | instruction | 0 | 34,708 | 9 | 69,416 |
Yes | output | 1 | 34,708 | 9 | 69,417 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
Karafs is some kind of vegetable in shape of an 1 × h rectangle. Tavaspolis people love Karafs and they use Karafs in almost any kind of food. Tavas, himself, is crazy about Karafs.
<image>
Each Karafs has a positive integer height. Tavas has an infinite 1-based sequence of Karafses. The height of the i-th Karafs is si = A + (i - 1) × B.
For a given m, let's define an m-bite operation as decreasing the height of at most m distinct not eaten Karafses by 1. Karafs is considered as eaten when its height becomes zero.
Now SaDDas asks you n queries. In each query he gives you numbers l, t and m and you should find the largest number r such that l ≤ r and sequence sl, sl + 1, ..., sr can be eaten by performing m-bite no more than t times or print -1 if there is no such number r.
Input
The first line of input contains three integers A, B and n (1 ≤ A, B ≤ 106, 1 ≤ n ≤ 105).
Next n lines contain information about queries. i-th line contains integers l, t, m (1 ≤ l, t, m ≤ 106) for i-th query.
Output
For each query, print its answer in a single line.
Examples
Input
2 1 4
1 5 3
3 3 10
7 10 2
6 4 8
Output
4
-1
8
-1
Input
1 5 2
1 5 10
2 7 4
Output
1
2
Submitted Solution:
```
from sys import stdin
A,B,n = [int(x) for x in stdin.readline().split()]
for q in range(n):
l,t,m = [int(x) for x in stdin.readline().split()]
l -= 1
if B*l+A > t:
print(-1)
else:
const = A*(l-1)+(B*(l-1)*(l-2))//2
high = (t-A)//B
low = l+1
while high >= low:
mid = (low+high)//2
total = A*mid+(B*mid*(mid-1))//2-const
if total <= t*m:
low = mid+1
else:
high = mid-1
print(high+1)
``` | instruction | 0 | 34,709 | 9 | 69,418 |
No | output | 1 | 34,709 | 9 | 69,419 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
Karafs is some kind of vegetable in shape of an 1 × h rectangle. Tavaspolis people love Karafs and they use Karafs in almost any kind of food. Tavas, himself, is crazy about Karafs.
<image>
Each Karafs has a positive integer height. Tavas has an infinite 1-based sequence of Karafses. The height of the i-th Karafs is si = A + (i - 1) × B.
For a given m, let's define an m-bite operation as decreasing the height of at most m distinct not eaten Karafses by 1. Karafs is considered as eaten when its height becomes zero.
Now SaDDas asks you n queries. In each query he gives you numbers l, t and m and you should find the largest number r such that l ≤ r and sequence sl, sl + 1, ..., sr can be eaten by performing m-bite no more than t times or print -1 if there is no such number r.
Input
The first line of input contains three integers A, B and n (1 ≤ A, B ≤ 106, 1 ≤ n ≤ 105).
Next n lines contain information about queries. i-th line contains integers l, t, m (1 ≤ l, t, m ≤ 106) for i-th query.
Output
For each query, print its answer in a single line.
Examples
Input
2 1 4
1 5 3
3 3 10
7 10 2
6 4 8
Output
4
-1
8
-1
Input
1 5 2
1 5 10
2 7 4
Output
1
2
Submitted Solution:
```
from collections import defaultdict,deque,Counter
import sys
import bisect
import math
input=sys.stdin.readline
mod=1000000007
a,b,n=map(int,input().split())
for ii in range(n):
l,t,m=map(int,input().split())
lo=l
hi=100000000
while lo<hi:
mid=(lo+hi)//2
count=(mid-l)+1
first=a+(l-1)*b
last=a+(mid-1)*b
#print('aaaaa',first,last,(count*(first+last))/2)
if last<=t and (count*(first+last))//2<=m*t:
lo=mid+1
else:
hi=mid
if mid!=lo:
print(mid)
else:
count=(mid-1-l)+1
first=a+(l-1)*b
last=a+(mid-1-1)*b
if last<=t and (count*(first+last))//2<=m*t:
print(mid-1)
else:
print(-1)
``` | instruction | 0 | 34,710 | 9 | 69,420 |
No | output | 1 | 34,710 | 9 | 69,421 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
Karafs is some kind of vegetable in shape of an 1 × h rectangle. Tavaspolis people love Karafs and they use Karafs in almost any kind of food. Tavas, himself, is crazy about Karafs.
<image>
Each Karafs has a positive integer height. Tavas has an infinite 1-based sequence of Karafses. The height of the i-th Karafs is si = A + (i - 1) × B.
For a given m, let's define an m-bite operation as decreasing the height of at most m distinct not eaten Karafses by 1. Karafs is considered as eaten when its height becomes zero.
Now SaDDas asks you n queries. In each query he gives you numbers l, t and m and you should find the largest number r such that l ≤ r and sequence sl, sl + 1, ..., sr can be eaten by performing m-bite no more than t times or print -1 if there is no such number r.
Input
The first line of input contains three integers A, B and n (1 ≤ A, B ≤ 106, 1 ≤ n ≤ 105).
Next n lines contain information about queries. i-th line contains integers l, t, m (1 ≤ l, t, m ≤ 106) for i-th query.
Output
For each query, print its answer in a single line.
Examples
Input
2 1 4
1 5 3
3 3 10
7 10 2
6 4 8
Output
4
-1
8
-1
Input
1 5 2
1 5 10
2 7 4
Output
1
2
Submitted Solution:
```
# -*- coding: utf-8 -*-
"""
Created on Wed Apr 15 01:59:52 2015
codeforces 299 Div 2 C
"""
import sys
def read_data():
A, B, n = map(int, input().split())
ltm = sys.stdin.readlines()
return A, B, ltm
def solve(A, B, ltm):
for line in ltm:
L, t, m = map(int, line.split())
print(max_r(L, t, m, A, B))
def max_r(L, t, m, A, B):
r_upper = (t - A) // B + 2
if r_upper <= L:
return -1
r_lower = L
threshold = (t * m - A) * 2
while r_upper > r_lower + 1:
mid = (r_upper + r_lower) // 2
# if is_possible(L, t, m, A, B, mid):
if B * (L + mid - 2) * (mid - L + 1) <= threshold:
r_lower = mid
else:
r_upper = mid
return r_lower
def is_possible(L, t, m, A, B, mid):
# Sr = A + B * (mid - 1)
# Sl = A + B * (L - 1)
# S = (Sr + Sl) * (mid - L + 1) // 2
# return A + B * (L + mid - 2) * (mid - L + 1) // 2 <= t * m
return B * (L + mid - 2) * (mid - L + 1) <= (t * m - A) * 2
A, B, ltm = read_data()
solve(A, B, ltm)
``` | instruction | 0 | 34,711 | 9 | 69,422 |
No | output | 1 | 34,711 | 9 | 69,423 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
Karafs is some kind of vegetable in shape of an 1 × h rectangle. Tavaspolis people love Karafs and they use Karafs in almost any kind of food. Tavas, himself, is crazy about Karafs.
<image>
Each Karafs has a positive integer height. Tavas has an infinite 1-based sequence of Karafses. The height of the i-th Karafs is si = A + (i - 1) × B.
For a given m, let's define an m-bite operation as decreasing the height of at most m distinct not eaten Karafses by 1. Karafs is considered as eaten when its height becomes zero.
Now SaDDas asks you n queries. In each query he gives you numbers l, t and m and you should find the largest number r such that l ≤ r and sequence sl, sl + 1, ..., sr can be eaten by performing m-bite no more than t times or print -1 if there is no such number r.
Input
The first line of input contains three integers A, B and n (1 ≤ A, B ≤ 106, 1 ≤ n ≤ 105).
Next n lines contain information about queries. i-th line contains integers l, t, m (1 ≤ l, t, m ≤ 106) for i-th query.
Output
For each query, print its answer in a single line.
Examples
Input
2 1 4
1 5 3
3 3 10
7 10 2
6 4 8
Output
4
-1
8
-1
Input
1 5 2
1 5 10
2 7 4
Output
1
2
Submitted Solution:
```
from math import sqrt
inp = input()
l = list(map(int, inp.split(' ')))
A = l[0]
B = l[1]
n = l[2]
for i in range(n):
inp = input()
temp = list(map(int, inp.split(' ')))
l = temp[0]
t = temp[1]
m = temp[2]
imp = 0
a = B/2
b = (A - 1/2 * B)
c = -A * (l - 1) + B*l/2 - B*l*l/2 + B - t*m
res1 = 0
if b*b - 4 * a * c > 0:
res1 = int((-b + sqrt(b*b - 4 * a*c) )/ (2 *a))
else:
imp = 1
res2 = 0
if (t - A - B*(-1))/B > 0:
res2 = int((t - A - B*(-1))/B)
else:
imp = 1
if res2 < l:
imp = 1
if not imp:
print(min(res1, res2))
else:
print(-1)
``` | instruction | 0 | 34,712 | 9 | 69,424 |
No | output | 1 | 34,712 | 9 | 69,425 |
Provide tags and a correct Python 3 solution for this coding contest problem.
Nikolay has a lemons, b apples and c pears. He decided to cook a compote. According to the recipe the fruits should be in the ratio 1: 2: 4. It means that for each lemon in the compote should be exactly 2 apples and exactly 4 pears. You can't crumble up, break up or cut these fruits into pieces. These fruits — lemons, apples and pears — should be put in the compote as whole fruits.
Your task is to determine the maximum total number of lemons, apples and pears from which Nikolay can cook the compote. It is possible that Nikolay can't use any fruits, in this case print 0.
Input
The first line contains the positive integer a (1 ≤ a ≤ 1000) — the number of lemons Nikolay has.
The second line contains the positive integer b (1 ≤ b ≤ 1000) — the number of apples Nikolay has.
The third line contains the positive integer c (1 ≤ c ≤ 1000) — the number of pears Nikolay has.
Output
Print the maximum total number of lemons, apples and pears from which Nikolay can cook the compote.
Examples
Input
2
5
7
Output
7
Input
4
7
13
Output
21
Input
2
3
2
Output
0
Note
In the first example Nikolay can use 1 lemon, 2 apples and 4 pears, so the answer is 1 + 2 + 4 = 7.
In the second example Nikolay can use 3 lemons, 6 apples and 12 pears, so the answer is 3 + 6 + 12 = 21.
In the third example Nikolay don't have enough pears to cook any compote, so the answer is 0. | instruction | 0 | 34,782 | 9 | 69,564 |
Tags: implementation, math
Correct Solution:
```
a=eval(input())
b=eval(input())
c=eval(input())
k=0
while(a>0 and b>0 and c>0):
if(a>=1 and b>=2 and c>=4):
k+=1
a-=1
b-=2
c-=4
print(k*7)
``` | output | 1 | 34,782 | 9 | 69,565 |
Provide tags and a correct Python 3 solution for this coding contest problem.
Nikolay has a lemons, b apples and c pears. He decided to cook a compote. According to the recipe the fruits should be in the ratio 1: 2: 4. It means that for each lemon in the compote should be exactly 2 apples and exactly 4 pears. You can't crumble up, break up or cut these fruits into pieces. These fruits — lemons, apples and pears — should be put in the compote as whole fruits.
Your task is to determine the maximum total number of lemons, apples and pears from which Nikolay can cook the compote. It is possible that Nikolay can't use any fruits, in this case print 0.
Input
The first line contains the positive integer a (1 ≤ a ≤ 1000) — the number of lemons Nikolay has.
The second line contains the positive integer b (1 ≤ b ≤ 1000) — the number of apples Nikolay has.
The third line contains the positive integer c (1 ≤ c ≤ 1000) — the number of pears Nikolay has.
Output
Print the maximum total number of lemons, apples and pears from which Nikolay can cook the compote.
Examples
Input
2
5
7
Output
7
Input
4
7
13
Output
21
Input
2
3
2
Output
0
Note
In the first example Nikolay can use 1 lemon, 2 apples and 4 pears, so the answer is 1 + 2 + 4 = 7.
In the second example Nikolay can use 3 lemons, 6 apples and 12 pears, so the answer is 3 + 6 + 12 = 21.
In the third example Nikolay don't have enough pears to cook any compote, so the answer is 0. | instruction | 0 | 34,783 | 9 | 69,566 |
Tags: implementation, math
Correct Solution:
```
a = int(input())
b = int(input())
c = int(input())
d = min(min(a//1,b//2),c//4)
print(d*7)
``` | output | 1 | 34,783 | 9 | 69,567 |
Provide tags and a correct Python 3 solution for this coding contest problem.
Nikolay has a lemons, b apples and c pears. He decided to cook a compote. According to the recipe the fruits should be in the ratio 1: 2: 4. It means that for each lemon in the compote should be exactly 2 apples and exactly 4 pears. You can't crumble up, break up or cut these fruits into pieces. These fruits — lemons, apples and pears — should be put in the compote as whole fruits.
Your task is to determine the maximum total number of lemons, apples and pears from which Nikolay can cook the compote. It is possible that Nikolay can't use any fruits, in this case print 0.
Input
The first line contains the positive integer a (1 ≤ a ≤ 1000) — the number of lemons Nikolay has.
The second line contains the positive integer b (1 ≤ b ≤ 1000) — the number of apples Nikolay has.
The third line contains the positive integer c (1 ≤ c ≤ 1000) — the number of pears Nikolay has.
Output
Print the maximum total number of lemons, apples and pears from which Nikolay can cook the compote.
Examples
Input
2
5
7
Output
7
Input
4
7
13
Output
21
Input
2
3
2
Output
0
Note
In the first example Nikolay can use 1 lemon, 2 apples and 4 pears, so the answer is 1 + 2 + 4 = 7.
In the second example Nikolay can use 3 lemons, 6 apples and 12 pears, so the answer is 3 + 6 + 12 = 21.
In the third example Nikolay don't have enough pears to cook any compote, so the answer is 0. | instruction | 0 | 34,784 | 9 | 69,568 |
Tags: implementation, math
Correct Solution:
```
def Main(l, a, p):
if ( p <= a or p <= l ) and p < 4:
print(0)
else:
mn = min(l//1, a//2, p//4)
print(mn + (mn*2) + ((mn*2)*2))
if __name__ == '__main__':
l = int(input())
a = int(input())
p = int(input())
Main(l,a,p)
``` | output | 1 | 34,784 | 9 | 69,569 |
Provide tags and a correct Python 3 solution for this coding contest problem.
Nikolay has a lemons, b apples and c pears. He decided to cook a compote. According to the recipe the fruits should be in the ratio 1: 2: 4. It means that for each lemon in the compote should be exactly 2 apples and exactly 4 pears. You can't crumble up, break up or cut these fruits into pieces. These fruits — lemons, apples and pears — should be put in the compote as whole fruits.
Your task is to determine the maximum total number of lemons, apples and pears from which Nikolay can cook the compote. It is possible that Nikolay can't use any fruits, in this case print 0.
Input
The first line contains the positive integer a (1 ≤ a ≤ 1000) — the number of lemons Nikolay has.
The second line contains the positive integer b (1 ≤ b ≤ 1000) — the number of apples Nikolay has.
The third line contains the positive integer c (1 ≤ c ≤ 1000) — the number of pears Nikolay has.
Output
Print the maximum total number of lemons, apples and pears from which Nikolay can cook the compote.
Examples
Input
2
5
7
Output
7
Input
4
7
13
Output
21
Input
2
3
2
Output
0
Note
In the first example Nikolay can use 1 lemon, 2 apples and 4 pears, so the answer is 1 + 2 + 4 = 7.
In the second example Nikolay can use 3 lemons, 6 apples and 12 pears, so the answer is 3 + 6 + 12 = 21.
In the third example Nikolay don't have enough pears to cook any compote, so the answer is 0. | instruction | 0 | 34,785 | 9 | 69,570 |
Tags: implementation, math
Correct Solution:
```
lemons=int(input().strip('\n'))
apples= int(input().strip('\n'))
pears=int(input().strip('\n'))
nb=[lemons,apples//2,pears//4]
total=min(nb)+min(nb)*2+min(nb)*4
print(total)
``` | output | 1 | 34,785 | 9 | 69,571 |
Provide tags and a correct Python 3 solution for this coding contest problem.
Nikolay has a lemons, b apples and c pears. He decided to cook a compote. According to the recipe the fruits should be in the ratio 1: 2: 4. It means that for each lemon in the compote should be exactly 2 apples and exactly 4 pears. You can't crumble up, break up or cut these fruits into pieces. These fruits — lemons, apples and pears — should be put in the compote as whole fruits.
Your task is to determine the maximum total number of lemons, apples and pears from which Nikolay can cook the compote. It is possible that Nikolay can't use any fruits, in this case print 0.
Input
The first line contains the positive integer a (1 ≤ a ≤ 1000) — the number of lemons Nikolay has.
The second line contains the positive integer b (1 ≤ b ≤ 1000) — the number of apples Nikolay has.
The third line contains the positive integer c (1 ≤ c ≤ 1000) — the number of pears Nikolay has.
Output
Print the maximum total number of lemons, apples and pears from which Nikolay can cook the compote.
Examples
Input
2
5
7
Output
7
Input
4
7
13
Output
21
Input
2
3
2
Output
0
Note
In the first example Nikolay can use 1 lemon, 2 apples and 4 pears, so the answer is 1 + 2 + 4 = 7.
In the second example Nikolay can use 3 lemons, 6 apples and 12 pears, so the answer is 3 + 6 + 12 = 21.
In the third example Nikolay don't have enough pears to cook any compote, so the answer is 0. | instruction | 0 | 34,786 | 9 | 69,572 |
Tags: implementation, math
Correct Solution:
```
sum=0
a=int(input())
b=int(input())
c=int(input())
i=a
while i :
L=i;
A=2*i
P=4*i
if(A<=b and P<=c):
sum=L+P+A
break
else:
i=i-1
if(sum==0):
print(sum)
else:
print(sum)
``` | output | 1 | 34,786 | 9 | 69,573 |
Provide tags and a correct Python 3 solution for this coding contest problem.
Nikolay has a lemons, b apples and c pears. He decided to cook a compote. According to the recipe the fruits should be in the ratio 1: 2: 4. It means that for each lemon in the compote should be exactly 2 apples and exactly 4 pears. You can't crumble up, break up or cut these fruits into pieces. These fruits — lemons, apples and pears — should be put in the compote as whole fruits.
Your task is to determine the maximum total number of lemons, apples and pears from which Nikolay can cook the compote. It is possible that Nikolay can't use any fruits, in this case print 0.
Input
The first line contains the positive integer a (1 ≤ a ≤ 1000) — the number of lemons Nikolay has.
The second line contains the positive integer b (1 ≤ b ≤ 1000) — the number of apples Nikolay has.
The third line contains the positive integer c (1 ≤ c ≤ 1000) — the number of pears Nikolay has.
Output
Print the maximum total number of lemons, apples and pears from which Nikolay can cook the compote.
Examples
Input
2
5
7
Output
7
Input
4
7
13
Output
21
Input
2
3
2
Output
0
Note
In the first example Nikolay can use 1 lemon, 2 apples and 4 pears, so the answer is 1 + 2 + 4 = 7.
In the second example Nikolay can use 3 lemons, 6 apples and 12 pears, so the answer is 3 + 6 + 12 = 21.
In the third example Nikolay don't have enough pears to cook any compote, so the answer is 0. | instruction | 0 | 34,787 | 9 | 69,574 |
Tags: implementation, math
Correct Solution:
```
a=int(input())
b=int(input())
c=int(input())
val=min(a,b//2,c//4)
print(7*val)
``` | output | 1 | 34,787 | 9 | 69,575 |
Provide tags and a correct Python 3 solution for this coding contest problem.
Nikolay has a lemons, b apples and c pears. He decided to cook a compote. According to the recipe the fruits should be in the ratio 1: 2: 4. It means that for each lemon in the compote should be exactly 2 apples and exactly 4 pears. You can't crumble up, break up or cut these fruits into pieces. These fruits — lemons, apples and pears — should be put in the compote as whole fruits.
Your task is to determine the maximum total number of lemons, apples and pears from which Nikolay can cook the compote. It is possible that Nikolay can't use any fruits, in this case print 0.
Input
The first line contains the positive integer a (1 ≤ a ≤ 1000) — the number of lemons Nikolay has.
The second line contains the positive integer b (1 ≤ b ≤ 1000) — the number of apples Nikolay has.
The third line contains the positive integer c (1 ≤ c ≤ 1000) — the number of pears Nikolay has.
Output
Print the maximum total number of lemons, apples and pears from which Nikolay can cook the compote.
Examples
Input
2
5
7
Output
7
Input
4
7
13
Output
21
Input
2
3
2
Output
0
Note
In the first example Nikolay can use 1 lemon, 2 apples and 4 pears, so the answer is 1 + 2 + 4 = 7.
In the second example Nikolay can use 3 lemons, 6 apples and 12 pears, so the answer is 3 + 6 + 12 = 21.
In the third example Nikolay don't have enough pears to cook any compote, so the answer is 0. | instruction | 0 | 34,788 | 9 | 69,576 |
Tags: implementation, math
Correct Solution:
```
#import sys
#sys.stdin = open('in', 'r')
a = int(input())
b = int(input())
c = int(input())
#a = [int(x) for x in input().split()]
#a,b,c = map(int, input().split())
r = min(a, b//2, c//4)
print(r*7)
``` | output | 1 | 34,788 | 9 | 69,577 |
Provide tags and a correct Python 3 solution for this coding contest problem.
Nikolay has a lemons, b apples and c pears. He decided to cook a compote. According to the recipe the fruits should be in the ratio 1: 2: 4. It means that for each lemon in the compote should be exactly 2 apples and exactly 4 pears. You can't crumble up, break up or cut these fruits into pieces. These fruits — lemons, apples and pears — should be put in the compote as whole fruits.
Your task is to determine the maximum total number of lemons, apples and pears from which Nikolay can cook the compote. It is possible that Nikolay can't use any fruits, in this case print 0.
Input
The first line contains the positive integer a (1 ≤ a ≤ 1000) — the number of lemons Nikolay has.
The second line contains the positive integer b (1 ≤ b ≤ 1000) — the number of apples Nikolay has.
The third line contains the positive integer c (1 ≤ c ≤ 1000) — the number of pears Nikolay has.
Output
Print the maximum total number of lemons, apples and pears from which Nikolay can cook the compote.
Examples
Input
2
5
7
Output
7
Input
4
7
13
Output
21
Input
2
3
2
Output
0
Note
In the first example Nikolay can use 1 lemon, 2 apples and 4 pears, so the answer is 1 + 2 + 4 = 7.
In the second example Nikolay can use 3 lemons, 6 apples and 12 pears, so the answer is 3 + 6 + 12 = 21.
In the third example Nikolay don't have enough pears to cook any compote, so the answer is 0. | instruction | 0 | 34,789 | 9 | 69,578 |
Tags: implementation, math
Correct Solution:
```
a=int(input())
b=int(input())
c=int(input())
z=int(7*min(a,int(b/2),int(c/4)))
print(z)
``` | output | 1 | 34,789 | 9 | 69,579 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
Nikolay has a lemons, b apples and c pears. He decided to cook a compote. According to the recipe the fruits should be in the ratio 1: 2: 4. It means that for each lemon in the compote should be exactly 2 apples and exactly 4 pears. You can't crumble up, break up or cut these fruits into pieces. These fruits — lemons, apples and pears — should be put in the compote as whole fruits.
Your task is to determine the maximum total number of lemons, apples and pears from which Nikolay can cook the compote. It is possible that Nikolay can't use any fruits, in this case print 0.
Input
The first line contains the positive integer a (1 ≤ a ≤ 1000) — the number of lemons Nikolay has.
The second line contains the positive integer b (1 ≤ b ≤ 1000) — the number of apples Nikolay has.
The third line contains the positive integer c (1 ≤ c ≤ 1000) — the number of pears Nikolay has.
Output
Print the maximum total number of lemons, apples and pears from which Nikolay can cook the compote.
Examples
Input
2
5
7
Output
7
Input
4
7
13
Output
21
Input
2
3
2
Output
0
Note
In the first example Nikolay can use 1 lemon, 2 apples and 4 pears, so the answer is 1 + 2 + 4 = 7.
In the second example Nikolay can use 3 lemons, 6 apples and 12 pears, so the answer is 3 + 6 + 12 = 21.
In the third example Nikolay don't have enough pears to cook any compote, so the answer is 0.
Submitted Solution:
```
'''input
2
3
2
'''
a, b, c = int(input()), int(input()), int(input())
for x in range(a,-1,-1):
if 2*x <= b and 4*x <= c:
print(7*x)
break
``` | instruction | 0 | 34,790 | 9 | 69,580 |
Yes | output | 1 | 34,790 | 9 | 69,581 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
Nikolay has a lemons, b apples and c pears. He decided to cook a compote. According to the recipe the fruits should be in the ratio 1: 2: 4. It means that for each lemon in the compote should be exactly 2 apples and exactly 4 pears. You can't crumble up, break up or cut these fruits into pieces. These fruits — lemons, apples and pears — should be put in the compote as whole fruits.
Your task is to determine the maximum total number of lemons, apples and pears from which Nikolay can cook the compote. It is possible that Nikolay can't use any fruits, in this case print 0.
Input
The first line contains the positive integer a (1 ≤ a ≤ 1000) — the number of lemons Nikolay has.
The second line contains the positive integer b (1 ≤ b ≤ 1000) — the number of apples Nikolay has.
The third line contains the positive integer c (1 ≤ c ≤ 1000) — the number of pears Nikolay has.
Output
Print the maximum total number of lemons, apples and pears from which Nikolay can cook the compote.
Examples
Input
2
5
7
Output
7
Input
4
7
13
Output
21
Input
2
3
2
Output
0
Note
In the first example Nikolay can use 1 lemon, 2 apples and 4 pears, so the answer is 1 + 2 + 4 = 7.
In the second example Nikolay can use 3 lemons, 6 apples and 12 pears, so the answer is 3 + 6 + 12 = 21.
In the third example Nikolay don't have enough pears to cook any compote, so the answer is 0.
Submitted Solution:
```
a, b, c = int(input()), int(input()), int(input())
ans = min(a, b // 2, c // 4)
print(ans * 7)
``` | instruction | 0 | 34,791 | 9 | 69,582 |
Yes | output | 1 | 34,791 | 9 | 69,583 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
Nikolay has a lemons, b apples and c pears. He decided to cook a compote. According to the recipe the fruits should be in the ratio 1: 2: 4. It means that for each lemon in the compote should be exactly 2 apples and exactly 4 pears. You can't crumble up, break up or cut these fruits into pieces. These fruits — lemons, apples and pears — should be put in the compote as whole fruits.
Your task is to determine the maximum total number of lemons, apples and pears from which Nikolay can cook the compote. It is possible that Nikolay can't use any fruits, in this case print 0.
Input
The first line contains the positive integer a (1 ≤ a ≤ 1000) — the number of lemons Nikolay has.
The second line contains the positive integer b (1 ≤ b ≤ 1000) — the number of apples Nikolay has.
The third line contains the positive integer c (1 ≤ c ≤ 1000) — the number of pears Nikolay has.
Output
Print the maximum total number of lemons, apples and pears from which Nikolay can cook the compote.
Examples
Input
2
5
7
Output
7
Input
4
7
13
Output
21
Input
2
3
2
Output
0
Note
In the first example Nikolay can use 1 lemon, 2 apples and 4 pears, so the answer is 1 + 2 + 4 = 7.
In the second example Nikolay can use 3 lemons, 6 apples and 12 pears, so the answer is 3 + 6 + 12 = 21.
In the third example Nikolay don't have enough pears to cook any compote, so the answer is 0.
Submitted Solution:
```
"""
Author : co_devil Chirag Garg
Institute : JIIT
"""
from __future__ import division, print_function
from sys import stdin, stdout
import itertools, os, sys, threading
from collections import deque, Counter, OrderedDict, defaultdict
import heapq
from math import ceil, floor, log, sqrt, factorial, pow, pi, gcd
# from bisect import bisect_left,bisect_right
# from decimal import *,threading
from fractions import Fraction
"""from io import BytesIO, IOBase
if sys.version_info[0] < 3:
from __builtin__ import xrange as range
from future_builtins import ascii, filter, hex, map, oct, zip
else:
from builtins import str as __str__
str = lambda x=b'': x if type(x) is bytes else __str__(x).encode()
BUFSIZE = 8192
class FastIO(IOBase):
newlines = 0
def __init__(self, file):
self._buffer = BytesIO()
self._fd = file.fileno()
self._writable = 'x' in file.mode or 'r' not in file.mode
self.write = self._buffer.write if self._writable else None
def read(self):
return self._buffer.read() if self._buffer.tell() else os.read(self._fd, os.fstat(self._fd).st_size)
def readline(self):
while self.newlines == 0:
b, ptr = os.read(self._fd, max(os.fstat(self._fd).st_size, BUFSIZE)), self._buffer.tell()
self._buffer.seek(0, 2), self._buffer.write(b), self._buffer.seek(ptr)
self.newlines += b.count(b'\n') + (not b)
self.newlines -= 1
return self._buffer.readline()
def flush(self):
if self._writable:
os.write(self._fd, self._buffer.getvalue())
self._buffer.truncate(0), self._buffer.seek(0)
sys.stdin, sys.stdout = FastIO(sys.stdin), FastIO(sys.stdout)
input = lambda: sys.stdin.readline().rstrip(b'\r\n')
def print(*args, **kwargs):
sep, file = kwargs.pop('sep', b' '), kwargs.pop('file', sys.stdout)
at_start = True
for x in args:
if not at_start:
file.write(sep)
file.write(str(x))
at_start = False
file.write(kwargs.pop('end', b'\n'))
if kwargs.pop('flush', False):
file.flush()
"""
def ii(): return int(input())
def si(): return str(input())
def mi(): return map(int, input().split())
def li(): return list(mi())
def fii(): return int(stdin.readline())
def fsi(): return str(stdin.readline())
def fmi(): return map(int, stdin.readline().split())
def fli(): return list(fmi())
abc = 'abcdefghijklmnopqrstuvwxyz'
abd = {'a': 0, 'b': 1, 'c': 2, 'd': 3, 'e': 4, 'f': 5, 'g': 6, 'h': 7, 'i': 8, 'j': 9, 'k': 10, 'l': 11, 'm': 12,
'n': 13, 'o': 14, 'p': 15, 'q': 16, 'r': 17, 's': 18, 't': 19, 'u': 20, 'v': 21, 'w': 22, 'x': 23, 'y': 24,
'z': 25}
mod = 1000000007
dx, dy = [-1, 1, 0, 0], [0, 0, 1, -1]
def getKey(item): return item[0]
def sort2(l): return sorted(l, key=getKey)
def d2(n, m, num): return [[num for x in range(m)] for y in range(n)]
def isPowerOfTwo(x): return (x and (not (x & (x - 1))))
def decimalToBinary(n): return bin(n).replace("0b", "")
def ntl(n): return [int(i) for i in str(n)]
def powerMod(x, y, p):
res = 1
x %= p
while y > 0:
if y & 1:
res = (res * x) % p
y = y >> 1
x = (x * x) % p
return res
def gcd(x, y):
while y:
x, y = y, x % y
return x
# For getting input from input.txt file
# sys.stdin = open('input.txt', 'r')
# Printing the Output to output.txt file
# sys.stdout = open('output.txt', 'w')
graph = defaultdict(list)
visited = [0] * 1000000
col = [-1] * 1000000
def dfs(v, c):
if visited[v]:
if col[v] != c:
print('-1')
exit()
return
col[v] = c
visited[v] = 1
for i in graph[v]:
dfs(i, c ^ 1)
def bfs(d, v):
q = []
q.append(v)
visited[v] = 1
while len(q) != 0:
x = q[0]
q.pop(0)
for i in d[x]:
if visited[i] != 1:
visited[i] = 1
q.append(i)
print(x)
def make_graph(e):
d = {}
for i in range(e):
x, y = mi()
if x not in d.keys():
d[x] = [y]
else:
d[x].append(y)
if y not in d.keys():
d[y] = [x]
else:
d[y].append(x)
return d
def gr2(n):
d = {}
for i in range(n):
x, y = mi()
if x not in d.keys():
d[x] = [y]
else:
d[x].append(y)
return d
def connected_components(graph):
seen = set()
def dfs(v):
vs = set([v])
component = []
while vs:
v = vs.pop()
seen.add(v)
vs |= set(graph[v]) - seen
component.append(v)
return component
ans = []
for v in graph:
if v not in seen:
d = dfs(v)
ans.append(d)
return ans
def primeFactors(n):
s = set()
while n % 2 == 0:
s.add(2)
n = n // 2
for i in range(3, int(sqrt(n)) + 1, 2):
while n % i == 0:
s.add(i)
n = n // i
if n > 2:
s.add(n)
return s
def find_all(a_str, sub):
start = 0
while True:
start = a_str.find(sub, start)
if start == -1: return
yield start
start += len(sub)
a=ii()
b=ii()
c=ii()
count=0
while a>0 and b>1 and c>3:
count+=7
a-=1
b-=2
c-=4
print(count)
``` | instruction | 0 | 34,792 | 9 | 69,584 |
Yes | output | 1 | 34,792 | 9 | 69,585 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
Nikolay has a lemons, b apples and c pears. He decided to cook a compote. According to the recipe the fruits should be in the ratio 1: 2: 4. It means that for each lemon in the compote should be exactly 2 apples and exactly 4 pears. You can't crumble up, break up or cut these fruits into pieces. These fruits — lemons, apples and pears — should be put in the compote as whole fruits.
Your task is to determine the maximum total number of lemons, apples and pears from which Nikolay can cook the compote. It is possible that Nikolay can't use any fruits, in this case print 0.
Input
The first line contains the positive integer a (1 ≤ a ≤ 1000) — the number of lemons Nikolay has.
The second line contains the positive integer b (1 ≤ b ≤ 1000) — the number of apples Nikolay has.
The third line contains the positive integer c (1 ≤ c ≤ 1000) — the number of pears Nikolay has.
Output
Print the maximum total number of lemons, apples and pears from which Nikolay can cook the compote.
Examples
Input
2
5
7
Output
7
Input
4
7
13
Output
21
Input
2
3
2
Output
0
Note
In the first example Nikolay can use 1 lemon, 2 apples and 4 pears, so the answer is 1 + 2 + 4 = 7.
In the second example Nikolay can use 3 lemons, 6 apples and 12 pears, so the answer is 3 + 6 + 12 = 21.
In the third example Nikolay don't have enough pears to cook any compote, so the answer is 0.
Submitted Solution:
```
import math
a=int(input())
b=int(input())
c=int(input())
d=[]
k=int(math.floor(b/2))
l=int(math.floor(c/4))
d.append(a)
d.append(k)
d.append(l)
d.sort()
if d[0]=='0':
print(0)
t=int(d[0])
ans=int(t*1+t*2+t*4)
print(ans)
``` | instruction | 0 | 34,793 | 9 | 69,586 |
Yes | output | 1 | 34,793 | 9 | 69,587 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
Nikolay has a lemons, b apples and c pears. He decided to cook a compote. According to the recipe the fruits should be in the ratio 1: 2: 4. It means that for each lemon in the compote should be exactly 2 apples and exactly 4 pears. You can't crumble up, break up or cut these fruits into pieces. These fruits — lemons, apples and pears — should be put in the compote as whole fruits.
Your task is to determine the maximum total number of lemons, apples and pears from which Nikolay can cook the compote. It is possible that Nikolay can't use any fruits, in this case print 0.
Input
The first line contains the positive integer a (1 ≤ a ≤ 1000) — the number of lemons Nikolay has.
The second line contains the positive integer b (1 ≤ b ≤ 1000) — the number of apples Nikolay has.
The third line contains the positive integer c (1 ≤ c ≤ 1000) — the number of pears Nikolay has.
Output
Print the maximum total number of lemons, apples and pears from which Nikolay can cook the compote.
Examples
Input
2
5
7
Output
7
Input
4
7
13
Output
21
Input
2
3
2
Output
0
Note
In the first example Nikolay can use 1 lemon, 2 apples and 4 pears, so the answer is 1 + 2 + 4 = 7.
In the second example Nikolay can use 3 lemons, 6 apples and 12 pears, so the answer is 3 + 6 + 12 = 21.
In the third example Nikolay don't have enough pears to cook any compote, so the answer is 0.
Submitted Solution:
```
x=int(input())
y=int(input())
z=int(input())
a=1
b=2
c=4
d=7
e=0
for i in range(100):
if a+b+c<=d and a<=x and b<=y and c<=z:
e+=7
a=a+1
b=a*2
c=a*2
d+=a+b+c
print(e)
``` | instruction | 0 | 34,794 | 9 | 69,588 |
No | output | 1 | 34,794 | 9 | 69,589 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
Nikolay has a lemons, b apples and c pears. He decided to cook a compote. According to the recipe the fruits should be in the ratio 1: 2: 4. It means that for each lemon in the compote should be exactly 2 apples and exactly 4 pears. You can't crumble up, break up or cut these fruits into pieces. These fruits — lemons, apples and pears — should be put in the compote as whole fruits.
Your task is to determine the maximum total number of lemons, apples and pears from which Nikolay can cook the compote. It is possible that Nikolay can't use any fruits, in this case print 0.
Input
The first line contains the positive integer a (1 ≤ a ≤ 1000) — the number of lemons Nikolay has.
The second line contains the positive integer b (1 ≤ b ≤ 1000) — the number of apples Nikolay has.
The third line contains the positive integer c (1 ≤ c ≤ 1000) — the number of pears Nikolay has.
Output
Print the maximum total number of lemons, apples and pears from which Nikolay can cook the compote.
Examples
Input
2
5
7
Output
7
Input
4
7
13
Output
21
Input
2
3
2
Output
0
Note
In the first example Nikolay can use 1 lemon, 2 apples and 4 pears, so the answer is 1 + 2 + 4 = 7.
In the second example Nikolay can use 3 lemons, 6 apples and 12 pears, so the answer is 3 + 6 + 12 = 21.
In the third example Nikolay don't have enough pears to cook any compote, so the answer is 0.
Submitted Solution:
```
a=int(input())
b=int(input())
c=int(input())
ss=0
for i in range(0,6):
if a<=b/2 and a<=c/4:
ss=1
break
else:
a-=1
if ss==1:
print(a*1+a*2+a*4)
else:
print(0)
``` | instruction | 0 | 34,795 | 9 | 69,590 |
No | output | 1 | 34,795 | 9 | 69,591 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
Nikolay has a lemons, b apples and c pears. He decided to cook a compote. According to the recipe the fruits should be in the ratio 1: 2: 4. It means that for each lemon in the compote should be exactly 2 apples and exactly 4 pears. You can't crumble up, break up or cut these fruits into pieces. These fruits — lemons, apples and pears — should be put in the compote as whole fruits.
Your task is to determine the maximum total number of lemons, apples and pears from which Nikolay can cook the compote. It is possible that Nikolay can't use any fruits, in this case print 0.
Input
The first line contains the positive integer a (1 ≤ a ≤ 1000) — the number of lemons Nikolay has.
The second line contains the positive integer b (1 ≤ b ≤ 1000) — the number of apples Nikolay has.
The third line contains the positive integer c (1 ≤ c ≤ 1000) — the number of pears Nikolay has.
Output
Print the maximum total number of lemons, apples and pears from which Nikolay can cook the compote.
Examples
Input
2
5
7
Output
7
Input
4
7
13
Output
21
Input
2
3
2
Output
0
Note
In the first example Nikolay can use 1 lemon, 2 apples and 4 pears, so the answer is 1 + 2 + 4 = 7.
In the second example Nikolay can use 3 lemons, 6 apples and 12 pears, so the answer is 3 + 6 + 12 = 21.
In the third example Nikolay don't have enough pears to cook any compote, so the answer is 0.
Submitted Solution:
```
def solve(lemons, apples, pears):
oneCompote = 1 + 2 + 4
l = lemons/1
a = apples/2
p = pears/4
return min(l,a,p) * oneCompote
if __name__ == "__main__":
lemons = int(input())
apples = int(input())
pears = int(input())
print(solve(lemons, apples, pears))
``` | instruction | 0 | 34,796 | 9 | 69,592 |
No | output | 1 | 34,796 | 9 | 69,593 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
Nikolay has a lemons, b apples and c pears. He decided to cook a compote. According to the recipe the fruits should be in the ratio 1: 2: 4. It means that for each lemon in the compote should be exactly 2 apples and exactly 4 pears. You can't crumble up, break up or cut these fruits into pieces. These fruits — lemons, apples and pears — should be put in the compote as whole fruits.
Your task is to determine the maximum total number of lemons, apples and pears from which Nikolay can cook the compote. It is possible that Nikolay can't use any fruits, in this case print 0.
Input
The first line contains the positive integer a (1 ≤ a ≤ 1000) — the number of lemons Nikolay has.
The second line contains the positive integer b (1 ≤ b ≤ 1000) — the number of apples Nikolay has.
The third line contains the positive integer c (1 ≤ c ≤ 1000) — the number of pears Nikolay has.
Output
Print the maximum total number of lemons, apples and pears from which Nikolay can cook the compote.
Examples
Input
2
5
7
Output
7
Input
4
7
13
Output
21
Input
2
3
2
Output
0
Note
In the first example Nikolay can use 1 lemon, 2 apples and 4 pears, so the answer is 1 + 2 + 4 = 7.
In the second example Nikolay can use 3 lemons, 6 apples and 12 pears, so the answer is 3 + 6 + 12 = 21.
In the third example Nikolay don't have enough pears to cook any compote, so the answer is 0.
Submitted Solution:
```
a=int(input())
b=int(input())
c=int(input())
x=0
z=0
if(a==1):
x=1
while(c<=a*4):
a-=1
if(a==0):
break
elif(c>a*4):
c-=4
b-=2
x+=1
else:
print(0)
z=1
break
if(z==0):
print(7*x)
``` | instruction | 0 | 34,797 | 9 | 69,594 |
No | output | 1 | 34,797 | 9 | 69,595 |
Provide a correct Python 3 solution for this coding contest problem.
Some number of chocolate pieces were prepared for a training camp. The camp had N participants and lasted for D days. The i-th participant (1 \leq i \leq N) ate one chocolate piece on each of the following days in the camp: the 1-st day, the (A_i + 1)-th day, the (2A_i + 1)-th day, and so on. As a result, there were X chocolate pieces remaining at the end of the camp. During the camp, nobody except the participants ate chocolate pieces.
Find the number of chocolate pieces prepared at the beginning of the camp.
Constraints
* 1 \leq N \leq 100
* 1 \leq D \leq 100
* 1 \leq X \leq 100
* 1 \leq A_i \leq 100 (1 \leq i \leq N)
* All input values are integers.
Input
Input is given from Standard Input in the following format:
N
D X
A_1
A_2
:
A_N
Output
Find the number of chocolate pieces prepared at the beginning of the camp.
Examples
Input
3
7 1
2
5
10
Output
8
Input
2
8 20
1
10
Output
29
Input
5
30 44
26
18
81
18
6
Output
56 | instruction | 0 | 34,979 | 9 | 69,958 |
"Correct Solution:
```
n = int(input())
d, x = map(int,input().split())
c = 0
for i in range(n):
a = int(input())
c += (d-1) // a +1
print(c+x)
``` | output | 1 | 34,979 | 9 | 69,959 |
Provide a correct Python 3 solution for this coding contest problem.
Some number of chocolate pieces were prepared for a training camp. The camp had N participants and lasted for D days. The i-th participant (1 \leq i \leq N) ate one chocolate piece on each of the following days in the camp: the 1-st day, the (A_i + 1)-th day, the (2A_i + 1)-th day, and so on. As a result, there were X chocolate pieces remaining at the end of the camp. During the camp, nobody except the participants ate chocolate pieces.
Find the number of chocolate pieces prepared at the beginning of the camp.
Constraints
* 1 \leq N \leq 100
* 1 \leq D \leq 100
* 1 \leq X \leq 100
* 1 \leq A_i \leq 100 (1 \leq i \leq N)
* All input values are integers.
Input
Input is given from Standard Input in the following format:
N
D X
A_1
A_2
:
A_N
Output
Find the number of chocolate pieces prepared at the beginning of the camp.
Examples
Input
3
7 1
2
5
10
Output
8
Input
2
8 20
1
10
Output
29
Input
5
30 44
26
18
81
18
6
Output
56 | instruction | 0 | 34,980 | 9 | 69,960 |
"Correct Solution:
```
n=int(input())
d,x=map(int,input().split())
for i in range(n):
x+=1+((d-1)//int(input()))
print(x)
``` | output | 1 | 34,980 | 9 | 69,961 |
Provide a correct Python 3 solution for this coding contest problem.
Some number of chocolate pieces were prepared for a training camp. The camp had N participants and lasted for D days. The i-th participant (1 \leq i \leq N) ate one chocolate piece on each of the following days in the camp: the 1-st day, the (A_i + 1)-th day, the (2A_i + 1)-th day, and so on. As a result, there were X chocolate pieces remaining at the end of the camp. During the camp, nobody except the participants ate chocolate pieces.
Find the number of chocolate pieces prepared at the beginning of the camp.
Constraints
* 1 \leq N \leq 100
* 1 \leq D \leq 100
* 1 \leq X \leq 100
* 1 \leq A_i \leq 100 (1 \leq i \leq N)
* All input values are integers.
Input
Input is given from Standard Input in the following format:
N
D X
A_1
A_2
:
A_N
Output
Find the number of chocolate pieces prepared at the beginning of the camp.
Examples
Input
3
7 1
2
5
10
Output
8
Input
2
8 20
1
10
Output
29
Input
5
30 44
26
18
81
18
6
Output
56 | instruction | 0 | 34,981 | 9 | 69,962 |
"Correct Solution:
```
n=int(input())
d,x=map(int,input().split())
for i in range(n):
a=int(input())
x+=d//a+[1,0][d%a==0]
print(x)
``` | output | 1 | 34,981 | 9 | 69,963 |
Provide a correct Python 3 solution for this coding contest problem.
Some number of chocolate pieces were prepared for a training camp. The camp had N participants and lasted for D days. The i-th participant (1 \leq i \leq N) ate one chocolate piece on each of the following days in the camp: the 1-st day, the (A_i + 1)-th day, the (2A_i + 1)-th day, and so on. As a result, there were X chocolate pieces remaining at the end of the camp. During the camp, nobody except the participants ate chocolate pieces.
Find the number of chocolate pieces prepared at the beginning of the camp.
Constraints
* 1 \leq N \leq 100
* 1 \leq D \leq 100
* 1 \leq X \leq 100
* 1 \leq A_i \leq 100 (1 \leq i \leq N)
* All input values are integers.
Input
Input is given from Standard Input in the following format:
N
D X
A_1
A_2
:
A_N
Output
Find the number of chocolate pieces prepared at the beginning of the camp.
Examples
Input
3
7 1
2
5
10
Output
8
Input
2
8 20
1
10
Output
29
Input
5
30 44
26
18
81
18
6
Output
56 | instruction | 0 | 34,982 | 9 | 69,964 |
"Correct Solution:
```
N = int(input())
D,X = map(int,input().split())
S = X
for i in range(N):
a = int(input())
S += (D-1)//a+1
print(S)
``` | output | 1 | 34,982 | 9 | 69,965 |
Provide a correct Python 3 solution for this coding contest problem.
Some number of chocolate pieces were prepared for a training camp. The camp had N participants and lasted for D days. The i-th participant (1 \leq i \leq N) ate one chocolate piece on each of the following days in the camp: the 1-st day, the (A_i + 1)-th day, the (2A_i + 1)-th day, and so on. As a result, there were X chocolate pieces remaining at the end of the camp. During the camp, nobody except the participants ate chocolate pieces.
Find the number of chocolate pieces prepared at the beginning of the camp.
Constraints
* 1 \leq N \leq 100
* 1 \leq D \leq 100
* 1 \leq X \leq 100
* 1 \leq A_i \leq 100 (1 \leq i \leq N)
* All input values are integers.
Input
Input is given from Standard Input in the following format:
N
D X
A_1
A_2
:
A_N
Output
Find the number of chocolate pieces prepared at the beginning of the camp.
Examples
Input
3
7 1
2
5
10
Output
8
Input
2
8 20
1
10
Output
29
Input
5
30 44
26
18
81
18
6
Output
56 | instruction | 0 | 34,983 | 9 | 69,966 |
"Correct Solution:
```
N=int(input())
D,X=map(int,input().split())
ans = 0
for _ in range(N):
A=int(input())
ans += (D+A-1)//A
print(ans + X)
``` | output | 1 | 34,983 | 9 | 69,967 |
Provide a correct Python 3 solution for this coding contest problem.
Some number of chocolate pieces were prepared for a training camp. The camp had N participants and lasted for D days. The i-th participant (1 \leq i \leq N) ate one chocolate piece on each of the following days in the camp: the 1-st day, the (A_i + 1)-th day, the (2A_i + 1)-th day, and so on. As a result, there were X chocolate pieces remaining at the end of the camp. During the camp, nobody except the participants ate chocolate pieces.
Find the number of chocolate pieces prepared at the beginning of the camp.
Constraints
* 1 \leq N \leq 100
* 1 \leq D \leq 100
* 1 \leq X \leq 100
* 1 \leq A_i \leq 100 (1 \leq i \leq N)
* All input values are integers.
Input
Input is given from Standard Input in the following format:
N
D X
A_1
A_2
:
A_N
Output
Find the number of chocolate pieces prepared at the beginning of the camp.
Examples
Input
3
7 1
2
5
10
Output
8
Input
2
8 20
1
10
Output
29
Input
5
30 44
26
18
81
18
6
Output
56 | instruction | 0 | 34,984 | 9 | 69,968 |
"Correct Solution:
```
N=int(input())
D,X=map(int,input().split())
ans=0
for _ in[0]*N:
A=int(input())
ans+=(D+A-1)//A
print(ans+X)
``` | output | 1 | 34,984 | 9 | 69,969 |
Provide a correct Python 3 solution for this coding contest problem.
Some number of chocolate pieces were prepared for a training camp. The camp had N participants and lasted for D days. The i-th participant (1 \leq i \leq N) ate one chocolate piece on each of the following days in the camp: the 1-st day, the (A_i + 1)-th day, the (2A_i + 1)-th day, and so on. As a result, there were X chocolate pieces remaining at the end of the camp. During the camp, nobody except the participants ate chocolate pieces.
Find the number of chocolate pieces prepared at the beginning of the camp.
Constraints
* 1 \leq N \leq 100
* 1 \leq D \leq 100
* 1 \leq X \leq 100
* 1 \leq A_i \leq 100 (1 \leq i \leq N)
* All input values are integers.
Input
Input is given from Standard Input in the following format:
N
D X
A_1
A_2
:
A_N
Output
Find the number of chocolate pieces prepared at the beginning of the camp.
Examples
Input
3
7 1
2
5
10
Output
8
Input
2
8 20
1
10
Output
29
Input
5
30 44
26
18
81
18
6
Output
56 | instruction | 0 | 34,985 | 9 | 69,970 |
"Correct Solution:
```
N = int(input())
D,X = map(int,input().split())
cho = X
for _ in range(N):
cho += (D-1)//int(input())+1
print(cho)
``` | output | 1 | 34,985 | 9 | 69,971 |
Provide a correct Python 3 solution for this coding contest problem.
Some number of chocolate pieces were prepared for a training camp. The camp had N participants and lasted for D days. The i-th participant (1 \leq i \leq N) ate one chocolate piece on each of the following days in the camp: the 1-st day, the (A_i + 1)-th day, the (2A_i + 1)-th day, and so on. As a result, there were X chocolate pieces remaining at the end of the camp. During the camp, nobody except the participants ate chocolate pieces.
Find the number of chocolate pieces prepared at the beginning of the camp.
Constraints
* 1 \leq N \leq 100
* 1 \leq D \leq 100
* 1 \leq X \leq 100
* 1 \leq A_i \leq 100 (1 \leq i \leq N)
* All input values are integers.
Input
Input is given from Standard Input in the following format:
N
D X
A_1
A_2
:
A_N
Output
Find the number of chocolate pieces prepared at the beginning of the camp.
Examples
Input
3
7 1
2
5
10
Output
8
Input
2
8 20
1
10
Output
29
Input
5
30 44
26
18
81
18
6
Output
56 | instruction | 0 | 34,986 | 9 | 69,972 |
"Correct Solution:
```
N = int(input())
D, X = map(int, input().split(' '))
for _ in range(N):
A = int(input())
X += (D + A - 1) // A
print(X)
``` | output | 1 | 34,986 | 9 | 69,973 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
Some number of chocolate pieces were prepared for a training camp. The camp had N participants and lasted for D days. The i-th participant (1 \leq i \leq N) ate one chocolate piece on each of the following days in the camp: the 1-st day, the (A_i + 1)-th day, the (2A_i + 1)-th day, and so on. As a result, there were X chocolate pieces remaining at the end of the camp. During the camp, nobody except the participants ate chocolate pieces.
Find the number of chocolate pieces prepared at the beginning of the camp.
Constraints
* 1 \leq N \leq 100
* 1 \leq D \leq 100
* 1 \leq X \leq 100
* 1 \leq A_i \leq 100 (1 \leq i \leq N)
* All input values are integers.
Input
Input is given from Standard Input in the following format:
N
D X
A_1
A_2
:
A_N
Output
Find the number of chocolate pieces prepared at the beginning of the camp.
Examples
Input
3
7 1
2
5
10
Output
8
Input
2
8 20
1
10
Output
29
Input
5
30 44
26
18
81
18
6
Output
56
Submitted Solution:
```
n,d,x,*a=map(int,open(0).read().split());print(sum(~-d//i+1for i in a)+x)
``` | instruction | 0 | 34,987 | 9 | 69,974 |
Yes | output | 1 | 34,987 | 9 | 69,975 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
Some number of chocolate pieces were prepared for a training camp. The camp had N participants and lasted for D days. The i-th participant (1 \leq i \leq N) ate one chocolate piece on each of the following days in the camp: the 1-st day, the (A_i + 1)-th day, the (2A_i + 1)-th day, and so on. As a result, there were X chocolate pieces remaining at the end of the camp. During the camp, nobody except the participants ate chocolate pieces.
Find the number of chocolate pieces prepared at the beginning of the camp.
Constraints
* 1 \leq N \leq 100
* 1 \leq D \leq 100
* 1 \leq X \leq 100
* 1 \leq A_i \leq 100 (1 \leq i \leq N)
* All input values are integers.
Input
Input is given from Standard Input in the following format:
N
D X
A_1
A_2
:
A_N
Output
Find the number of chocolate pieces prepared at the beginning of the camp.
Examples
Input
3
7 1
2
5
10
Output
8
Input
2
8 20
1
10
Output
29
Input
5
30 44
26
18
81
18
6
Output
56
Submitted Solution:
```
n=int(input())
d,x=map(int,input().split())
a=[int(input()) for _ in range(n)]
c=0
for ai in a:
c+=1+(d-1)//ai
print(c+x)
``` | instruction | 0 | 34,988 | 9 | 69,976 |
Yes | output | 1 | 34,988 | 9 | 69,977 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
Some number of chocolate pieces were prepared for a training camp. The camp had N participants and lasted for D days. The i-th participant (1 \leq i \leq N) ate one chocolate piece on each of the following days in the camp: the 1-st day, the (A_i + 1)-th day, the (2A_i + 1)-th day, and so on. As a result, there were X chocolate pieces remaining at the end of the camp. During the camp, nobody except the participants ate chocolate pieces.
Find the number of chocolate pieces prepared at the beginning of the camp.
Constraints
* 1 \leq N \leq 100
* 1 \leq D \leq 100
* 1 \leq X \leq 100
* 1 \leq A_i \leq 100 (1 \leq i \leq N)
* All input values are integers.
Input
Input is given from Standard Input in the following format:
N
D X
A_1
A_2
:
A_N
Output
Find the number of chocolate pieces prepared at the beginning of the camp.
Examples
Input
3
7 1
2
5
10
Output
8
Input
2
8 20
1
10
Output
29
Input
5
30 44
26
18
81
18
6
Output
56
Submitted Solution:
```
n = int(input())
d, x = map(int, input().split())
for i in range(n):
a = int(input())
x += (1+(d-1)//a)
print(x)
``` | instruction | 0 | 34,989 | 9 | 69,978 |
Yes | output | 1 | 34,989 | 9 | 69,979 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
Some number of chocolate pieces were prepared for a training camp. The camp had N participants and lasted for D days. The i-th participant (1 \leq i \leq N) ate one chocolate piece on each of the following days in the camp: the 1-st day, the (A_i + 1)-th day, the (2A_i + 1)-th day, and so on. As a result, there were X chocolate pieces remaining at the end of the camp. During the camp, nobody except the participants ate chocolate pieces.
Find the number of chocolate pieces prepared at the beginning of the camp.
Constraints
* 1 \leq N \leq 100
* 1 \leq D \leq 100
* 1 \leq X \leq 100
* 1 \leq A_i \leq 100 (1 \leq i \leq N)
* All input values are integers.
Input
Input is given from Standard Input in the following format:
N
D X
A_1
A_2
:
A_N
Output
Find the number of chocolate pieces prepared at the beginning of the camp.
Examples
Input
3
7 1
2
5
10
Output
8
Input
2
8 20
1
10
Output
29
Input
5
30 44
26
18
81
18
6
Output
56
Submitted Solution:
```
N = int(input())
D, X = map(int,input().split())
c = 0
for i in range(N):
c = c + 1 + (D-1)//(int(input()))
print(X + c)
``` | instruction | 0 | 34,990 | 9 | 69,980 |
Yes | output | 1 | 34,990 | 9 | 69,981 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
Some number of chocolate pieces were prepared for a training camp. The camp had N participants and lasted for D days. The i-th participant (1 \leq i \leq N) ate one chocolate piece on each of the following days in the camp: the 1-st day, the (A_i + 1)-th day, the (2A_i + 1)-th day, and so on. As a result, there were X chocolate pieces remaining at the end of the camp. During the camp, nobody except the participants ate chocolate pieces.
Find the number of chocolate pieces prepared at the beginning of the camp.
Constraints
* 1 \leq N \leq 100
* 1 \leq D \leq 100
* 1 \leq X \leq 100
* 1 \leq A_i \leq 100 (1 \leq i \leq N)
* All input values are integers.
Input
Input is given from Standard Input in the following format:
N
D X
A_1
A_2
:
A_N
Output
Find the number of chocolate pieces prepared at the beginning of the camp.
Examples
Input
3
7 1
2
5
10
Output
8
Input
2
8 20
1
10
Output
29
Input
5
30 44
26
18
81
18
6
Output
56
Submitted Solution:
```
n=int(input())
d,x=map(int,input().split())
for i in range(n):
a=int(input())
x+=(d-1)//a
print(x)
``` | instruction | 0 | 34,991 | 9 | 69,982 |
No | output | 1 | 34,991 | 9 | 69,983 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
Some number of chocolate pieces were prepared for a training camp. The camp had N participants and lasted for D days. The i-th participant (1 \leq i \leq N) ate one chocolate piece on each of the following days in the camp: the 1-st day, the (A_i + 1)-th day, the (2A_i + 1)-th day, and so on. As a result, there were X chocolate pieces remaining at the end of the camp. During the camp, nobody except the participants ate chocolate pieces.
Find the number of chocolate pieces prepared at the beginning of the camp.
Constraints
* 1 \leq N \leq 100
* 1 \leq D \leq 100
* 1 \leq X \leq 100
* 1 \leq A_i \leq 100 (1 \leq i \leq N)
* All input values are integers.
Input
Input is given from Standard Input in the following format:
N
D X
A_1
A_2
:
A_N
Output
Find the number of chocolate pieces prepared at the beginning of the camp.
Examples
Input
3
7 1
2
5
10
Output
8
Input
2
8 20
1
10
Output
29
Input
5
30 44
26
18
81
18
6
Output
56
Submitted Solution:
```
from typing import List
n = int(input())
day, x = map(int, input().split())
a = [int(input()) for _ in range(n)]
def choco(cday):
sum = 0
for i in range(day):
if cday * i + 1 <= day:
sum += 1
return sum
csum = sum(list(map(choco, a))) + x
print(csum)
``` | instruction | 0 | 34,992 | 9 | 69,984 |
No | output | 1 | 34,992 | 9 | 69,985 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
Some number of chocolate pieces were prepared for a training camp. The camp had N participants and lasted for D days. The i-th participant (1 \leq i \leq N) ate one chocolate piece on each of the following days in the camp: the 1-st day, the (A_i + 1)-th day, the (2A_i + 1)-th day, and so on. As a result, there were X chocolate pieces remaining at the end of the camp. During the camp, nobody except the participants ate chocolate pieces.
Find the number of chocolate pieces prepared at the beginning of the camp.
Constraints
* 1 \leq N \leq 100
* 1 \leq D \leq 100
* 1 \leq X \leq 100
* 1 \leq A_i \leq 100 (1 \leq i \leq N)
* All input values are integers.
Input
Input is given from Standard Input in the following format:
N
D X
A_1
A_2
:
A_N
Output
Find the number of chocolate pieces prepared at the beginning of the camp.
Examples
Input
3
7 1
2
5
10
Output
8
Input
2
8 20
1
10
Output
29
Input
5
30 44
26
18
81
18
6
Output
56
Submitted Solution:
```
n=int(input())
d,x=map(int,input().split())
cnt=n
for i in range(n):
a=int(input())
a += 1
if a <= d:
cnt += 1
a += a
print(cnt+x)
``` | instruction | 0 | 34,993 | 9 | 69,986 |
No | output | 1 | 34,993 | 9 | 69,987 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
Some number of chocolate pieces were prepared for a training camp. The camp had N participants and lasted for D days. The i-th participant (1 \leq i \leq N) ate one chocolate piece on each of the following days in the camp: the 1-st day, the (A_i + 1)-th day, the (2A_i + 1)-th day, and so on. As a result, there were X chocolate pieces remaining at the end of the camp. During the camp, nobody except the participants ate chocolate pieces.
Find the number of chocolate pieces prepared at the beginning of the camp.
Constraints
* 1 \leq N \leq 100
* 1 \leq D \leq 100
* 1 \leq X \leq 100
* 1 \leq A_i \leq 100 (1 \leq i \leq N)
* All input values are integers.
Input
Input is given from Standard Input in the following format:
N
D X
A_1
A_2
:
A_N
Output
Find the number of chocolate pieces prepared at the beginning of the camp.
Examples
Input
3
7 1
2
5
10
Output
8
Input
2
8 20
1
10
Output
29
Input
5
30 44
26
18
81
18
6
Output
56
Submitted Solution:
```
n = int(input())
d, x = map(int, input().split())
a = [int(input()) for _ in range(n)]
choco = [0] * n
for i in range(d-1):
for j in range(n):
if i*a[j] < d:
choco[j] += 1
print(sum(choco) + x)
``` | instruction | 0 | 34,994 | 9 | 69,988 |
No | output | 1 | 34,994 | 9 | 69,989 |
Provide a correct Python 3 solution for this coding contest problem.
Time Limit: 8 sec / Memory Limit: 64 MB
Example
Input
eggchickenegg
Output
egg | instruction | 0 | 35,105 | 9 | 70,210 |
"Correct Solution:
```
s=input()
i=c=p=0;b=''
while i<len(s):
if s[i]==b:
if c > p:r=b;p=c
c=0
b=s[i]
i+=[3,7][s[i]=='c']
c+=1
if c>p:r=b
print(['chicken','egg'][r=='e'])
``` | output | 1 | 35,105 | 9 | 70,211 |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.