message stringlengths 2 30.5k | message_type stringclasses 2 values | message_id int64 0 1 | conversation_id int64 237 109k | cluster float64 10 10 | __index_level_0__ int64 474 217k |
|---|---|---|---|---|---|
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
There are n incoming messages for Vasya. The i-th message is going to be received after ti minutes. Each message has a cost, which equals to A initially. After being received, the cost of a message decreases by B each minute (it can become negative). Vasya can read any message after receiving it at any moment of time. After reading the message, Vasya's bank account receives the current cost of this message. Initially, Vasya's bank account is at 0.
Also, each minute Vasya's bank account receives C·k, where k is the amount of received but unread messages.
Vasya's messages are very important to him, and because of that he wants to have all messages read after T minutes.
Determine the maximum amount of money Vasya's bank account can hold after T minutes.
Input
The first line contains five integers n, A, B, C and T (1 ≤ n, A, B, C, T ≤ 1000).
The second string contains n integers ti (1 ≤ ti ≤ T).
Output
Output one integer — the answer to the problem.
Examples
Input
4 5 5 3 5
1 5 5 4
Output
20
Input
5 3 1 1 3
2 2 2 1 1
Output
15
Input
5 5 3 4 5
1 2 3 4 5
Output
35
Note
In the first sample the messages must be read immediately after receiving, Vasya receives A points for each message, n·A = 20 in total.
In the second sample the messages can be read at any integer moment.
In the third sample messages must be read at the moment T. This way Vasya has 1, 2, 3, 4 and 0 unread messages at the corresponding minutes, he gets 40 points for them. When reading messages, he receives (5 - 4·3) + (5 - 3·3) + (5 - 2·3) + (5 - 1·3) + 5 = - 5 points. This is 35 in total.
Submitted Solution:
```
n, a, b, c, t = [int(x) for x in input().split()]
s = 0
for i in [int(x) for x in input().split()]:
s ++ max(a, a-b*(t-i)+c*(t-i))
print(s)
``` | instruction | 0 | 74,737 | 10 | 149,474 |
No | output | 1 | 74,737 | 10 | 149,475 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
You are running for a governor in a small city in Russia. You ran some polls and did some research, and for every person in the city you know whom he will vote for, and how much it will cost to bribe that person to vote for you instead of whomever he wants to vote for right now. You are curious, what is the smallest amount of money you need to spend on bribing to win the elections. To win elections you need to have strictly more votes than any other candidate.
Input
First line contains one integer n (1 ≤ n ≤ 105) — number of voters in the city. Each of the next n lines describes one voter and contains two integers ai and bi (0 ≤ ai ≤ 105; 0 ≤ bi ≤ 104) — number of the candidate that voter is going to vote for and amount of money you need to pay him to change his mind. You are the candidate 0 (so if a voter wants to vote for you, ai is equal to zero, in which case bi will also be equal to zero).
Output
Print one integer — smallest amount of money you need to spend to win the elections.
Examples
Input
5
1 2
1 2
1 2
2 1
0 0
Output
3
Input
4
1 2
1 2
2 1
0 0
Output
2
Input
1
100000 0
Output
0
Submitted Solution:
```
print(3)
``` | instruction | 0 | 75,417 | 10 | 150,834 |
No | output | 1 | 75,417 | 10 | 150,835 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
You are running for a governor in a small city in Russia. You ran some polls and did some research, and for every person in the city you know whom he will vote for, and how much it will cost to bribe that person to vote for you instead of whomever he wants to vote for right now. You are curious, what is the smallest amount of money you need to spend on bribing to win the elections. To win elections you need to have strictly more votes than any other candidate.
Input
First line contains one integer n (1 ≤ n ≤ 105) — number of voters in the city. Each of the next n lines describes one voter and contains two integers ai and bi (0 ≤ ai ≤ 105; 0 ≤ bi ≤ 104) — number of the candidate that voter is going to vote for and amount of money you need to pay him to change his mind. You are the candidate 0 (so if a voter wants to vote for you, ai is equal to zero, in which case bi will also be equal to zero).
Output
Print one integer — smallest amount of money you need to spend to win the elections.
Examples
Input
5
1 2
1 2
1 2
2 1
0 0
Output
3
Input
4
1 2
1 2
2 1
0 0
Output
2
Input
1
100000 0
Output
0
Submitted Solution:
```
def __main__():
n = int(input())
voteCnt = [0] * 100001
voters = []
for i in range(0, n):
voter = input().split(" ")
voter = [int(x) for x in voter]
[a, b] = voter
voteCnt[a] += 1
[a, b] = [b, a]
voters.append(voter)
voters.sort()
votesToBeat = max(voteCnt)
duplicates = False
for cnt in voteCnt:
if cnt == votesToBeat:
duplicates = True
break
minBribe = 0
if duplicates:
for [b, a] in voters:
voteCnt[a] -= 1
voteCnt[0] += 1
minBribe += b
if voteCnt[0] > votesToBeat:
break
print(minBribe)
__main__()
``` | instruction | 0 | 75,418 | 10 | 150,836 |
No | output | 1 | 75,418 | 10 | 150,837 |
Provide a correct Python 3 solution for this coding contest problem.
Mr. Matsudaira is always careful about eco-friendliness in his life. Last month's water charge was 4280 yen, which exceeded the usual target of 4000 yen, so we have been trying to save water this month. How much have you saved on your water bill compared to last month?
Enter this month's water usage w [m3] and create a program that outputs how much water charges you have saved compared to last month's water charges of 4280 yen.
The water charge is calculated as follows.
(Water charge) = (Basic charge) + (Charge based on water volume)
The charge based on the amount of water is calculated according to the amount used as shown in the table below.
Stage | Water volume | Price
--- | --- | ---
1st stage charge | Up to 10 [m3] | Basic charge 1150 yen
Second stage fee | 10 [m3] Excess up to 20 [m3] | 125 yen per [m3]
Third stage charge | 20 [m3] Excess up to 30 [m3] | 140 yen per [m3]
4th stage charge | 30 [m3] excess | 160 yen per [m3]
For example, if the amount of water used is 40 [m3], the basic charge is 1150 yen (1st stage) + 10 [m3] x 125 yen (2nd stage) + 10 [m3] x 140 yen (3rd stage) + 10 [ m3] x 160 yen (4th stage) = 5400 yen.
Input
A sequence of multiple datasets is given as input. The end of the input is indicated by a single line of -1.
For each dataset, an integer w (0 ≤ w ≤ 100) representing the amount of water used this month is given on one line.
The number of datasets does not exceed 200.
Output
For each input dataset, the difference from last month's water charges is output on one line.
Example
Input
29
40
0
-1
Output
620
-1120
3130 | instruction | 0 | 75,798 | 10 | 151,596 |
"Correct Solution:
```
pre = 4280
v = [0,125,140,160]
while True:
w = int(input())
if w == -1:break
s= 1150
amari = w
for i in reversed(range(1,4)):
if amari > i*10:
spam = amari - i*10
s += spam * v[i]
amari = i*10
print (pre - s)
``` | output | 1 | 75,798 | 10 | 151,597 |
Provide a correct Python 3 solution for this coding contest problem.
Mr. Matsudaira is always careful about eco-friendliness in his life. Last month's water charge was 4280 yen, which exceeded the usual target of 4000 yen, so we have been trying to save water this month. How much have you saved on your water bill compared to last month?
Enter this month's water usage w [m3] and create a program that outputs how much water charges you have saved compared to last month's water charges of 4280 yen.
The water charge is calculated as follows.
(Water charge) = (Basic charge) + (Charge based on water volume)
The charge based on the amount of water is calculated according to the amount used as shown in the table below.
Stage | Water volume | Price
--- | --- | ---
1st stage charge | Up to 10 [m3] | Basic charge 1150 yen
Second stage fee | 10 [m3] Excess up to 20 [m3] | 125 yen per [m3]
Third stage charge | 20 [m3] Excess up to 30 [m3] | 140 yen per [m3]
4th stage charge | 30 [m3] excess | 160 yen per [m3]
For example, if the amount of water used is 40 [m3], the basic charge is 1150 yen (1st stage) + 10 [m3] x 125 yen (2nd stage) + 10 [m3] x 140 yen (3rd stage) + 10 [ m3] x 160 yen (4th stage) = 5400 yen.
Input
A sequence of multiple datasets is given as input. The end of the input is indicated by a single line of -1.
For each dataset, an integer w (0 ≤ w ≤ 100) representing the amount of water used this month is given on one line.
The number of datasets does not exceed 200.
Output
For each input dataset, the difference from last month's water charges is output on one line.
Example
Input
29
40
0
-1
Output
620
-1120
3130 | instruction | 0 | 75,799 | 10 | 151,598 |
"Correct Solution:
```
def water_charges(w):
progressive_rate = {
(float('inf'),30):160,
(30,20):140,
(20,10):125,
(10, 0):0}
charge = basic_charge = 1150
for (upper, lower), rate in progressive_rate.items():
usage = min(w, upper) - lower
if 0 < usage:
charge += usage * rate
return charge
import sys
f = sys.stdin
last_water_charges = 4280
while True:
w = int(f.readline())
if w == -1:
break
print(last_water_charges - water_charges(w))
``` | output | 1 | 75,799 | 10 | 151,599 |
Provide a correct Python 3 solution for this coding contest problem.
Mr. Matsudaira is always careful about eco-friendliness in his life. Last month's water charge was 4280 yen, which exceeded the usual target of 4000 yen, so we have been trying to save water this month. How much have you saved on your water bill compared to last month?
Enter this month's water usage w [m3] and create a program that outputs how much water charges you have saved compared to last month's water charges of 4280 yen.
The water charge is calculated as follows.
(Water charge) = (Basic charge) + (Charge based on water volume)
The charge based on the amount of water is calculated according to the amount used as shown in the table below.
Stage | Water volume | Price
--- | --- | ---
1st stage charge | Up to 10 [m3] | Basic charge 1150 yen
Second stage fee | 10 [m3] Excess up to 20 [m3] | 125 yen per [m3]
Third stage charge | 20 [m3] Excess up to 30 [m3] | 140 yen per [m3]
4th stage charge | 30 [m3] excess | 160 yen per [m3]
For example, if the amount of water used is 40 [m3], the basic charge is 1150 yen (1st stage) + 10 [m3] x 125 yen (2nd stage) + 10 [m3] x 140 yen (3rd stage) + 10 [ m3] x 160 yen (4th stage) = 5400 yen.
Input
A sequence of multiple datasets is given as input. The end of the input is indicated by a single line of -1.
For each dataset, an integer w (0 ≤ w ≤ 100) representing the amount of water used this month is given on one line.
The number of datasets does not exceed 200.
Output
For each input dataset, the difference from last month's water charges is output on one line.
Example
Input
29
40
0
-1
Output
620
-1120
3130 | instruction | 0 | 75,800 | 10 | 151,600 |
"Correct Solution:
```
def f(w):
if w <= 10:
return 4280 - 1150
elif w <= 20:
return 4280 - (1150 + f1(w - 10))
elif w <= 30:
return 4280 - (1150 + f1(10) + f2(w - 20))
else:
return 4280 - (1150 + f1(10) + f2(10) + f3(w - 30))
def f1(x):
return x * 125
def f2(x):
return x * 140
def f3(x):
return x * 160
while True:
_w = int(input())
if _w == -1:
break
print(f(_w))
``` | output | 1 | 75,800 | 10 | 151,601 |
Provide a correct Python 3 solution for this coding contest problem.
Mr. Matsudaira is always careful about eco-friendliness in his life. Last month's water charge was 4280 yen, which exceeded the usual target of 4000 yen, so we have been trying to save water this month. How much have you saved on your water bill compared to last month?
Enter this month's water usage w [m3] and create a program that outputs how much water charges you have saved compared to last month's water charges of 4280 yen.
The water charge is calculated as follows.
(Water charge) = (Basic charge) + (Charge based on water volume)
The charge based on the amount of water is calculated according to the amount used as shown in the table below.
Stage | Water volume | Price
--- | --- | ---
1st stage charge | Up to 10 [m3] | Basic charge 1150 yen
Second stage fee | 10 [m3] Excess up to 20 [m3] | 125 yen per [m3]
Third stage charge | 20 [m3] Excess up to 30 [m3] | 140 yen per [m3]
4th stage charge | 30 [m3] excess | 160 yen per [m3]
For example, if the amount of water used is 40 [m3], the basic charge is 1150 yen (1st stage) + 10 [m3] x 125 yen (2nd stage) + 10 [m3] x 140 yen (3rd stage) + 10 [ m3] x 160 yen (4th stage) = 5400 yen.
Input
A sequence of multiple datasets is given as input. The end of the input is indicated by a single line of -1.
For each dataset, an integer w (0 ≤ w ≤ 100) representing the amount of water used this month is given on one line.
The number of datasets does not exceed 200.
Output
For each input dataset, the difference from last month's water charges is output on one line.
Example
Input
29
40
0
-1
Output
620
-1120
3130 | instruction | 0 | 75,801 | 10 | 151,602 |
"Correct Solution:
```
while 1 :
n=int(input())
if n==-1:
break
else:
if n<=10:
w=1150
elif 10<n<=20:
w=1150+(n-10)*125
elif 20<n<=30:
w=2400+(n-20)*140
else:
w=3800+(n-30)*160
print(4280-w)
``` | output | 1 | 75,801 | 10 | 151,603 |
Provide a correct Python 3 solution for this coding contest problem.
Mr. Matsudaira is always careful about eco-friendliness in his life. Last month's water charge was 4280 yen, which exceeded the usual target of 4000 yen, so we have been trying to save water this month. How much have you saved on your water bill compared to last month?
Enter this month's water usage w [m3] and create a program that outputs how much water charges you have saved compared to last month's water charges of 4280 yen.
The water charge is calculated as follows.
(Water charge) = (Basic charge) + (Charge based on water volume)
The charge based on the amount of water is calculated according to the amount used as shown in the table below.
Stage | Water volume | Price
--- | --- | ---
1st stage charge | Up to 10 [m3] | Basic charge 1150 yen
Second stage fee | 10 [m3] Excess up to 20 [m3] | 125 yen per [m3]
Third stage charge | 20 [m3] Excess up to 30 [m3] | 140 yen per [m3]
4th stage charge | 30 [m3] excess | 160 yen per [m3]
For example, if the amount of water used is 40 [m3], the basic charge is 1150 yen (1st stage) + 10 [m3] x 125 yen (2nd stage) + 10 [m3] x 140 yen (3rd stage) + 10 [ m3] x 160 yen (4th stage) = 5400 yen.
Input
A sequence of multiple datasets is given as input. The end of the input is indicated by a single line of -1.
For each dataset, an integer w (0 ≤ w ≤ 100) representing the amount of water used this month is given on one line.
The number of datasets does not exceed 200.
Output
For each input dataset, the difference from last month's water charges is output on one line.
Example
Input
29
40
0
-1
Output
620
-1120
3130 | instruction | 0 | 75,802 | 10 | 151,604 |
"Correct Solution:
```
while True:
n=int(input())
if n==-1:
break
a=4280
b=1150
if n<=10:
print(a-b)
elif 10<n<=20:
print(a-(b+(n-10)*125))
elif 20<n<=30:
print(a-(b+1250+(n-20)*140))
else:
print(a-(b+1250+1400+(n-30)*160))
``` | output | 1 | 75,802 | 10 | 151,605 |
Provide a correct Python 3 solution for this coding contest problem.
Mr. Matsudaira is always careful about eco-friendliness in his life. Last month's water charge was 4280 yen, which exceeded the usual target of 4000 yen, so we have been trying to save water this month. How much have you saved on your water bill compared to last month?
Enter this month's water usage w [m3] and create a program that outputs how much water charges you have saved compared to last month's water charges of 4280 yen.
The water charge is calculated as follows.
(Water charge) = (Basic charge) + (Charge based on water volume)
The charge based on the amount of water is calculated according to the amount used as shown in the table below.
Stage | Water volume | Price
--- | --- | ---
1st stage charge | Up to 10 [m3] | Basic charge 1150 yen
Second stage fee | 10 [m3] Excess up to 20 [m3] | 125 yen per [m3]
Third stage charge | 20 [m3] Excess up to 30 [m3] | 140 yen per [m3]
4th stage charge | 30 [m3] excess | 160 yen per [m3]
For example, if the amount of water used is 40 [m3], the basic charge is 1150 yen (1st stage) + 10 [m3] x 125 yen (2nd stage) + 10 [m3] x 140 yen (3rd stage) + 10 [ m3] x 160 yen (4th stage) = 5400 yen.
Input
A sequence of multiple datasets is given as input. The end of the input is indicated by a single line of -1.
For each dataset, an integer w (0 ≤ w ≤ 100) representing the amount of water used this month is given on one line.
The number of datasets does not exceed 200.
Output
For each input dataset, the difference from last month's water charges is output on one line.
Example
Input
29
40
0
-1
Output
620
-1120
3130 | instruction | 0 | 75,803 | 10 | 151,606 |
"Correct Solution:
```
# -*- coding: utf-8 -*-
"""
Cutting Down Water Bills
http://judge.u-aizu.ac.jp/onlinejudge/description.jsp?id=0216
"""
import sys
def solve(w):
ans = 1150
if w > 10:
ans += 125 * min(10, (w-10))
if w > 20:
ans += 140 * min(10, (w-20))
if w > 30:
ans += 160 * (w-30)
return 4280 - ans
def main(args):
while True:
w = int(input())
if w == -1:
break
ans = solve(w)
print(ans)
if __name__ == '__main__':
main(sys.argv[1:])
``` | output | 1 | 75,803 | 10 | 151,607 |
Provide a correct Python 3 solution for this coding contest problem.
Mr. Matsudaira is always careful about eco-friendliness in his life. Last month's water charge was 4280 yen, which exceeded the usual target of 4000 yen, so we have been trying to save water this month. How much have you saved on your water bill compared to last month?
Enter this month's water usage w [m3] and create a program that outputs how much water charges you have saved compared to last month's water charges of 4280 yen.
The water charge is calculated as follows.
(Water charge) = (Basic charge) + (Charge based on water volume)
The charge based on the amount of water is calculated according to the amount used as shown in the table below.
Stage | Water volume | Price
--- | --- | ---
1st stage charge | Up to 10 [m3] | Basic charge 1150 yen
Second stage fee | 10 [m3] Excess up to 20 [m3] | 125 yen per [m3]
Third stage charge | 20 [m3] Excess up to 30 [m3] | 140 yen per [m3]
4th stage charge | 30 [m3] excess | 160 yen per [m3]
For example, if the amount of water used is 40 [m3], the basic charge is 1150 yen (1st stage) + 10 [m3] x 125 yen (2nd stage) + 10 [m3] x 140 yen (3rd stage) + 10 [ m3] x 160 yen (4th stage) = 5400 yen.
Input
A sequence of multiple datasets is given as input. The end of the input is indicated by a single line of -1.
For each dataset, an integer w (0 ≤ w ≤ 100) representing the amount of water used this month is given on one line.
The number of datasets does not exceed 200.
Output
For each input dataset, the difference from last month's water charges is output on one line.
Example
Input
29
40
0
-1
Output
620
-1120
3130 | instruction | 0 | 75,804 | 10 | 151,608 |
"Correct Solution:
```
while True:
w = int(input())
if w==-1: break
if w <= 10:
mon = 1150
elif 10 < w <= 20:
mon = 1150 + (w-10)*125
elif 20 < w <= 30:
mon = 1150 + 1250 +(w-20)*140
else:
mon = 1150 + 1250 + 1400 +(w-30)*160
print(4280-mon)
``` | output | 1 | 75,804 | 10 | 151,609 |
Provide a correct Python 3 solution for this coding contest problem.
Mr. Matsudaira is always careful about eco-friendliness in his life. Last month's water charge was 4280 yen, which exceeded the usual target of 4000 yen, so we have been trying to save water this month. How much have you saved on your water bill compared to last month?
Enter this month's water usage w [m3] and create a program that outputs how much water charges you have saved compared to last month's water charges of 4280 yen.
The water charge is calculated as follows.
(Water charge) = (Basic charge) + (Charge based on water volume)
The charge based on the amount of water is calculated according to the amount used as shown in the table below.
Stage | Water volume | Price
--- | --- | ---
1st stage charge | Up to 10 [m3] | Basic charge 1150 yen
Second stage fee | 10 [m3] Excess up to 20 [m3] | 125 yen per [m3]
Third stage charge | 20 [m3] Excess up to 30 [m3] | 140 yen per [m3]
4th stage charge | 30 [m3] excess | 160 yen per [m3]
For example, if the amount of water used is 40 [m3], the basic charge is 1150 yen (1st stage) + 10 [m3] x 125 yen (2nd stage) + 10 [m3] x 140 yen (3rd stage) + 10 [ m3] x 160 yen (4th stage) = 5400 yen.
Input
A sequence of multiple datasets is given as input. The end of the input is indicated by a single line of -1.
For each dataset, an integer w (0 ≤ w ≤ 100) representing the amount of water used this month is given on one line.
The number of datasets does not exceed 200.
Output
For each input dataset, the difference from last month's water charges is output on one line.
Example
Input
29
40
0
-1
Output
620
-1120
3130 | instruction | 0 | 75,805 | 10 | 151,610 |
"Correct Solution:
```
# AOJ 0216 Cutting Down Water Bills
# Python3 2018.6.23 bal4u
while 1:
w = int(input())
if w < 0: break
s = 1150
if w > 10:
if w <= 20: s+= (w-10)*125
else: s += 1250
if w > 20:
if w <= 30: s += (w-20)*140
else: s += 1400
if w > 30: s += (w-30)*160;
print(4280-s)
``` | output | 1 | 75,805 | 10 | 151,611 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
Mr. Matsudaira is always careful about eco-friendliness in his life. Last month's water charge was 4280 yen, which exceeded the usual target of 4000 yen, so we have been trying to save water this month. How much have you saved on your water bill compared to last month?
Enter this month's water usage w [m3] and create a program that outputs how much water charges you have saved compared to last month's water charges of 4280 yen.
The water charge is calculated as follows.
(Water charge) = (Basic charge) + (Charge based on water volume)
The charge based on the amount of water is calculated according to the amount used as shown in the table below.
Stage | Water volume | Price
--- | --- | ---
1st stage charge | Up to 10 [m3] | Basic charge 1150 yen
Second stage fee | 10 [m3] Excess up to 20 [m3] | 125 yen per [m3]
Third stage charge | 20 [m3] Excess up to 30 [m3] | 140 yen per [m3]
4th stage charge | 30 [m3] excess | 160 yen per [m3]
For example, if the amount of water used is 40 [m3], the basic charge is 1150 yen (1st stage) + 10 [m3] x 125 yen (2nd stage) + 10 [m3] x 140 yen (3rd stage) + 10 [ m3] x 160 yen (4th stage) = 5400 yen.
Input
A sequence of multiple datasets is given as input. The end of the input is indicated by a single line of -1.
For each dataset, an integer w (0 ≤ w ≤ 100) representing the amount of water used this month is given on one line.
The number of datasets does not exceed 200.
Output
For each input dataset, the difference from last month's water charges is output on one line.
Example
Input
29
40
0
-1
Output
620
-1120
3130
Submitted Solution:
```
while 1:
n=int(input())
if n==-1:break
w=1150
if n>30:
w+=(n-30)*160
n-=n-30
if n>20:
w+=(n-20)*140
n-=n-20
if n>10:
w+=(n-10)*125
print(4280-w)
``` | instruction | 0 | 75,806 | 10 | 151,612 |
Yes | output | 1 | 75,806 | 10 | 151,613 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
Mr. Matsudaira is always careful about eco-friendliness in his life. Last month's water charge was 4280 yen, which exceeded the usual target of 4000 yen, so we have been trying to save water this month. How much have you saved on your water bill compared to last month?
Enter this month's water usage w [m3] and create a program that outputs how much water charges you have saved compared to last month's water charges of 4280 yen.
The water charge is calculated as follows.
(Water charge) = (Basic charge) + (Charge based on water volume)
The charge based on the amount of water is calculated according to the amount used as shown in the table below.
Stage | Water volume | Price
--- | --- | ---
1st stage charge | Up to 10 [m3] | Basic charge 1150 yen
Second stage fee | 10 [m3] Excess up to 20 [m3] | 125 yen per [m3]
Third stage charge | 20 [m3] Excess up to 30 [m3] | 140 yen per [m3]
4th stage charge | 30 [m3] excess | 160 yen per [m3]
For example, if the amount of water used is 40 [m3], the basic charge is 1150 yen (1st stage) + 10 [m3] x 125 yen (2nd stage) + 10 [m3] x 140 yen (3rd stage) + 10 [ m3] x 160 yen (4th stage) = 5400 yen.
Input
A sequence of multiple datasets is given as input. The end of the input is indicated by a single line of -1.
For each dataset, an integer w (0 ≤ w ≤ 100) representing the amount of water used this month is given on one line.
The number of datasets does not exceed 200.
Output
For each input dataset, the difference from last month's water charges is output on one line.
Example
Input
29
40
0
-1
Output
620
-1120
3130
Submitted Solution:
```
def fee(w):
acc = 1150
if w <= 10:
return acc
w -= 10
if w <= 10:
return acc + 125 * w
acc += 1250
w -= 10
if w <= 10:
return acc + 140 * w
acc += 1400
w-= 10
return acc + 160 * w
while True:
w = int(input())
if w == -1:
break
print(4280 - fee(w))
``` | instruction | 0 | 75,807 | 10 | 151,614 |
Yes | output | 1 | 75,807 | 10 | 151,615 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
Mr. Matsudaira is always careful about eco-friendliness in his life. Last month's water charge was 4280 yen, which exceeded the usual target of 4000 yen, so we have been trying to save water this month. How much have you saved on your water bill compared to last month?
Enter this month's water usage w [m3] and create a program that outputs how much water charges you have saved compared to last month's water charges of 4280 yen.
The water charge is calculated as follows.
(Water charge) = (Basic charge) + (Charge based on water volume)
The charge based on the amount of water is calculated according to the amount used as shown in the table below.
Stage | Water volume | Price
--- | --- | ---
1st stage charge | Up to 10 [m3] | Basic charge 1150 yen
Second stage fee | 10 [m3] Excess up to 20 [m3] | 125 yen per [m3]
Third stage charge | 20 [m3] Excess up to 30 [m3] | 140 yen per [m3]
4th stage charge | 30 [m3] excess | 160 yen per [m3]
For example, if the amount of water used is 40 [m3], the basic charge is 1150 yen (1st stage) + 10 [m3] x 125 yen (2nd stage) + 10 [m3] x 140 yen (3rd stage) + 10 [ m3] x 160 yen (4th stage) = 5400 yen.
Input
A sequence of multiple datasets is given as input. The end of the input is indicated by a single line of -1.
For each dataset, an integer w (0 ≤ w ≤ 100) representing the amount of water used this month is given on one line.
The number of datasets does not exceed 200.
Output
For each input dataset, the difference from last month's water charges is output on one line.
Example
Input
29
40
0
-1
Output
620
-1120
3130
Submitted Solution:
```
while True :
w = int(input())
if w == -1 :
break
if w < 10 :
print(4280-1150)
elif w < 20 :
print(4280-(1150+(w-10)*125))
elif w < 30 :
print(4280-(1150+10*125+(w-20)*140))
else :
print(4280-(1150+10*125+10*140+(w-30)*160))
``` | instruction | 0 | 75,808 | 10 | 151,616 |
Yes | output | 1 | 75,808 | 10 | 151,617 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
Mr. Matsudaira is always careful about eco-friendliness in his life. Last month's water charge was 4280 yen, which exceeded the usual target of 4000 yen, so we have been trying to save water this month. How much have you saved on your water bill compared to last month?
Enter this month's water usage w [m3] and create a program that outputs how much water charges you have saved compared to last month's water charges of 4280 yen.
The water charge is calculated as follows.
(Water charge) = (Basic charge) + (Charge based on water volume)
The charge based on the amount of water is calculated according to the amount used as shown in the table below.
Stage | Water volume | Price
--- | --- | ---
1st stage charge | Up to 10 [m3] | Basic charge 1150 yen
Second stage fee | 10 [m3] Excess up to 20 [m3] | 125 yen per [m3]
Third stage charge | 20 [m3] Excess up to 30 [m3] | 140 yen per [m3]
4th stage charge | 30 [m3] excess | 160 yen per [m3]
For example, if the amount of water used is 40 [m3], the basic charge is 1150 yen (1st stage) + 10 [m3] x 125 yen (2nd stage) + 10 [m3] x 140 yen (3rd stage) + 10 [ m3] x 160 yen (4th stage) = 5400 yen.
Input
A sequence of multiple datasets is given as input. The end of the input is indicated by a single line of -1.
For each dataset, an integer w (0 ≤ w ≤ 100) representing the amount of water used this month is given on one line.
The number of datasets does not exceed 200.
Output
For each input dataset, the difference from last month's water charges is output on one line.
Example
Input
29
40
0
-1
Output
620
-1120
3130
Submitted Solution:
```
while True:
N=int(input())
if N== -1:
break
S=1150
if N>30:
S=S+(N-30)*160
N-=N-30
if N>20:
S=S+(N-20)*140
N-=N-20
if N>10:
S=S+(N-10)*125
print(4280-S)
``` | instruction | 0 | 75,809 | 10 | 151,618 |
Yes | output | 1 | 75,809 | 10 | 151,619 |
Provide tags and a correct Python 3 solution for this coding contest problem.
You got a job as a marketer in a pet shop, and your current task is to boost sales of cat food. One of the strategies is to sell cans of food in packs with discounts.
Suppose you decided to sell packs with a cans in a pack with a discount and some customer wants to buy x cans of cat food. Then he follows a greedy strategy:
* he buys \left⌊ x/a \right⌋ packs with a discount;
* then he wants to buy the remaining (x mod a) cans one by one.
\left⌊ x/a \right⌋ is x divided by a rounded down, x mod a is the remainer of x divided by a.
But customers are greedy in general, so if the customer wants to buy (x mod a) cans one by one and it happens that (x mod a) ≥ a/2 he decides to buy the whole pack of a cans (instead of buying (x mod a) cans). It makes you, as a marketer, happy since the customer bought more than he wanted initially.
You know that each of the customers that come to your shop can buy any number of cans from l to r inclusive. Can you choose such size of pack a that each customer buys more cans than they wanted initially?
Input
The first line contains a single integer t (1 ≤ t ≤ 1000) — the number of test cases.
The first and only line of each test case contains two integers l and r (1 ≤ l ≤ r ≤ 10^9) — the range of the number of cans customers can buy.
Output
For each test case, print YES if you can choose such size of pack a that each customer buys more cans than they wanted initially. Otherwise, print NO.
You can print each character in any case.
Example
Input
3
3 4
1 2
120 150
Output
YES
NO
YES
Note
In the first test case, you can take, for example, a = 5 as the size of the pack. Then if a customer wants to buy 3 cans, he'll buy 5 instead (3 mod 5 = 3, 5/2 = 2.5). The one who wants 4 cans will also buy 5 cans.
In the second test case, there is no way to choose a.
In the third test case, you can take, for example, a = 80. | instruction | 0 | 76,072 | 10 | 152,144 |
Tags: brute force, constructive algorithms, greedy, math
Correct Solution:
```
import sys
#import math
#from queue import *
#import random
#sys.setrecursionlimit(int(1e6))
input = sys.stdin.readline
############ ---- USER DEFINED INPUT FUNCTIONS ---- ############
def inp():
return(int(input()))
def inara():
return(list(map(int,input().split())))
def insr():
s = input()
return(list(s[:len(s) - 1]))
def invr():
return(map(int,input().split()))
################################################################
############ ---- THE ACTUAL CODE STARTS BELOW ---- ############
t=inp()
for _ in range(t):
l,r=invr()
if l*2>r:
print("YES")
else:
print("NO")
``` | output | 1 | 76,072 | 10 | 152,145 |
Provide tags and a correct Python 3 solution for this coding contest problem.
You got a job as a marketer in a pet shop, and your current task is to boost sales of cat food. One of the strategies is to sell cans of food in packs with discounts.
Suppose you decided to sell packs with a cans in a pack with a discount and some customer wants to buy x cans of cat food. Then he follows a greedy strategy:
* he buys \left⌊ x/a \right⌋ packs with a discount;
* then he wants to buy the remaining (x mod a) cans one by one.
\left⌊ x/a \right⌋ is x divided by a rounded down, x mod a is the remainer of x divided by a.
But customers are greedy in general, so if the customer wants to buy (x mod a) cans one by one and it happens that (x mod a) ≥ a/2 he decides to buy the whole pack of a cans (instead of buying (x mod a) cans). It makes you, as a marketer, happy since the customer bought more than he wanted initially.
You know that each of the customers that come to your shop can buy any number of cans from l to r inclusive. Can you choose such size of pack a that each customer buys more cans than they wanted initially?
Input
The first line contains a single integer t (1 ≤ t ≤ 1000) — the number of test cases.
The first and only line of each test case contains two integers l and r (1 ≤ l ≤ r ≤ 10^9) — the range of the number of cans customers can buy.
Output
For each test case, print YES if you can choose such size of pack a that each customer buys more cans than they wanted initially. Otherwise, print NO.
You can print each character in any case.
Example
Input
3
3 4
1 2
120 150
Output
YES
NO
YES
Note
In the first test case, you can take, for example, a = 5 as the size of the pack. Then if a customer wants to buy 3 cans, he'll buy 5 instead (3 mod 5 = 3, 5/2 = 2.5). The one who wants 4 cans will also buy 5 cans.
In the second test case, there is no way to choose a.
In the third test case, you can take, for example, a = 80. | instruction | 0 | 76,073 | 10 | 152,146 |
Tags: brute force, constructive algorithms, greedy, math
Correct Solution:
```
N=int(input())
l=[]
r=[]
ans=[]
for i in range(N):
t=list(map(int, input().split()))
if 2*t[0]>t[1]:
ans.append("YES")
else:
ans.append("NO")
for i in ans:
print (i)
``` | output | 1 | 76,073 | 10 | 152,147 |
Provide tags and a correct Python 3 solution for this coding contest problem.
You got a job as a marketer in a pet shop, and your current task is to boost sales of cat food. One of the strategies is to sell cans of food in packs with discounts.
Suppose you decided to sell packs with a cans in a pack with a discount and some customer wants to buy x cans of cat food. Then he follows a greedy strategy:
* he buys \left⌊ x/a \right⌋ packs with a discount;
* then he wants to buy the remaining (x mod a) cans one by one.
\left⌊ x/a \right⌋ is x divided by a rounded down, x mod a is the remainer of x divided by a.
But customers are greedy in general, so if the customer wants to buy (x mod a) cans one by one and it happens that (x mod a) ≥ a/2 he decides to buy the whole pack of a cans (instead of buying (x mod a) cans). It makes you, as a marketer, happy since the customer bought more than he wanted initially.
You know that each of the customers that come to your shop can buy any number of cans from l to r inclusive. Can you choose such size of pack a that each customer buys more cans than they wanted initially?
Input
The first line contains a single integer t (1 ≤ t ≤ 1000) — the number of test cases.
The first and only line of each test case contains two integers l and r (1 ≤ l ≤ r ≤ 10^9) — the range of the number of cans customers can buy.
Output
For each test case, print YES if you can choose such size of pack a that each customer buys more cans than they wanted initially. Otherwise, print NO.
You can print each character in any case.
Example
Input
3
3 4
1 2
120 150
Output
YES
NO
YES
Note
In the first test case, you can take, for example, a = 5 as the size of the pack. Then if a customer wants to buy 3 cans, he'll buy 5 instead (3 mod 5 = 3, 5/2 = 2.5). The one who wants 4 cans will also buy 5 cans.
In the second test case, there is no way to choose a.
In the third test case, you can take, for example, a = 80. | instruction | 0 | 76,074 | 10 | 152,148 |
Tags: brute force, constructive algorithms, greedy, math
Correct Solution:
```
for _ in range(int(input())):
l,r=map(int,input().split())
if(2*l>r):
print('YES')
else:
print('NO')
``` | output | 1 | 76,074 | 10 | 152,149 |
Provide tags and a correct Python 3 solution for this coding contest problem.
You got a job as a marketer in a pet shop, and your current task is to boost sales of cat food. One of the strategies is to sell cans of food in packs with discounts.
Suppose you decided to sell packs with a cans in a pack with a discount and some customer wants to buy x cans of cat food. Then he follows a greedy strategy:
* he buys \left⌊ x/a \right⌋ packs with a discount;
* then he wants to buy the remaining (x mod a) cans one by one.
\left⌊ x/a \right⌋ is x divided by a rounded down, x mod a is the remainer of x divided by a.
But customers are greedy in general, so if the customer wants to buy (x mod a) cans one by one and it happens that (x mod a) ≥ a/2 he decides to buy the whole pack of a cans (instead of buying (x mod a) cans). It makes you, as a marketer, happy since the customer bought more than he wanted initially.
You know that each of the customers that come to your shop can buy any number of cans from l to r inclusive. Can you choose such size of pack a that each customer buys more cans than they wanted initially?
Input
The first line contains a single integer t (1 ≤ t ≤ 1000) — the number of test cases.
The first and only line of each test case contains two integers l and r (1 ≤ l ≤ r ≤ 10^9) — the range of the number of cans customers can buy.
Output
For each test case, print YES if you can choose such size of pack a that each customer buys more cans than they wanted initially. Otherwise, print NO.
You can print each character in any case.
Example
Input
3
3 4
1 2
120 150
Output
YES
NO
YES
Note
In the first test case, you can take, for example, a = 5 as the size of the pack. Then if a customer wants to buy 3 cans, he'll buy 5 instead (3 mod 5 = 3, 5/2 = 2.5). The one who wants 4 cans will also buy 5 cans.
In the second test case, there is no way to choose a.
In the third test case, you can take, for example, a = 80. | instruction | 0 | 76,075 | 10 | 152,150 |
Tags: brute force, constructive algorithms, greedy, math
Correct Solution:
```
t = int(input())
for _ in range(t):
l, r = map(int, input().split())
if 2*l-r > 0:
print("YES")
else:
print("NO")
``` | output | 1 | 76,075 | 10 | 152,151 |
Provide tags and a correct Python 3 solution for this coding contest problem.
You got a job as a marketer in a pet shop, and your current task is to boost sales of cat food. One of the strategies is to sell cans of food in packs with discounts.
Suppose you decided to sell packs with a cans in a pack with a discount and some customer wants to buy x cans of cat food. Then he follows a greedy strategy:
* he buys \left⌊ x/a \right⌋ packs with a discount;
* then he wants to buy the remaining (x mod a) cans one by one.
\left⌊ x/a \right⌋ is x divided by a rounded down, x mod a is the remainer of x divided by a.
But customers are greedy in general, so if the customer wants to buy (x mod a) cans one by one and it happens that (x mod a) ≥ a/2 he decides to buy the whole pack of a cans (instead of buying (x mod a) cans). It makes you, as a marketer, happy since the customer bought more than he wanted initially.
You know that each of the customers that come to your shop can buy any number of cans from l to r inclusive. Can you choose such size of pack a that each customer buys more cans than they wanted initially?
Input
The first line contains a single integer t (1 ≤ t ≤ 1000) — the number of test cases.
The first and only line of each test case contains two integers l and r (1 ≤ l ≤ r ≤ 10^9) — the range of the number of cans customers can buy.
Output
For each test case, print YES if you can choose such size of pack a that each customer buys more cans than they wanted initially. Otherwise, print NO.
You can print each character in any case.
Example
Input
3
3 4
1 2
120 150
Output
YES
NO
YES
Note
In the first test case, you can take, for example, a = 5 as the size of the pack. Then if a customer wants to buy 3 cans, he'll buy 5 instead (3 mod 5 = 3, 5/2 = 2.5). The one who wants 4 cans will also buy 5 cans.
In the second test case, there is no way to choose a.
In the third test case, you can take, for example, a = 80. | instruction | 0 | 76,076 | 10 | 152,152 |
Tags: brute force, constructive algorithms, greedy, math
Correct Solution:
```
from math import *
sInt = lambda: int(input())
mInt = lambda: map(int, input().split())
lInt = lambda: list(map(int, input().split()))
t = sInt()
for _ in range(t):
l,r = mInt()
if l<=r//2:
print("NO")
else:
print("YES")
``` | output | 1 | 76,076 | 10 | 152,153 |
Provide tags and a correct Python 3 solution for this coding contest problem.
You got a job as a marketer in a pet shop, and your current task is to boost sales of cat food. One of the strategies is to sell cans of food in packs with discounts.
Suppose you decided to sell packs with a cans in a pack with a discount and some customer wants to buy x cans of cat food. Then he follows a greedy strategy:
* he buys \left⌊ x/a \right⌋ packs with a discount;
* then he wants to buy the remaining (x mod a) cans one by one.
\left⌊ x/a \right⌋ is x divided by a rounded down, x mod a is the remainer of x divided by a.
But customers are greedy in general, so if the customer wants to buy (x mod a) cans one by one and it happens that (x mod a) ≥ a/2 he decides to buy the whole pack of a cans (instead of buying (x mod a) cans). It makes you, as a marketer, happy since the customer bought more than he wanted initially.
You know that each of the customers that come to your shop can buy any number of cans from l to r inclusive. Can you choose such size of pack a that each customer buys more cans than they wanted initially?
Input
The first line contains a single integer t (1 ≤ t ≤ 1000) — the number of test cases.
The first and only line of each test case contains two integers l and r (1 ≤ l ≤ r ≤ 10^9) — the range of the number of cans customers can buy.
Output
For each test case, print YES if you can choose such size of pack a that each customer buys more cans than they wanted initially. Otherwise, print NO.
You can print each character in any case.
Example
Input
3
3 4
1 2
120 150
Output
YES
NO
YES
Note
In the first test case, you can take, for example, a = 5 as the size of the pack. Then if a customer wants to buy 3 cans, he'll buy 5 instead (3 mod 5 = 3, 5/2 = 2.5). The one who wants 4 cans will also buy 5 cans.
In the second test case, there is no way to choose a.
In the third test case, you can take, for example, a = 80. | instruction | 0 | 76,077 | 10 | 152,154 |
Tags: brute force, constructive algorithms, greedy, math
Correct Solution:
```
n = int(input())
for i in range(n):
l, r = map(int, input().split())
if 2*l > r:
print("YES")
else:
print("NO")
``` | output | 1 | 76,077 | 10 | 152,155 |
Provide tags and a correct Python 3 solution for this coding contest problem.
You got a job as a marketer in a pet shop, and your current task is to boost sales of cat food. One of the strategies is to sell cans of food in packs with discounts.
Suppose you decided to sell packs with a cans in a pack with a discount and some customer wants to buy x cans of cat food. Then he follows a greedy strategy:
* he buys \left⌊ x/a \right⌋ packs with a discount;
* then he wants to buy the remaining (x mod a) cans one by one.
\left⌊ x/a \right⌋ is x divided by a rounded down, x mod a is the remainer of x divided by a.
But customers are greedy in general, so if the customer wants to buy (x mod a) cans one by one and it happens that (x mod a) ≥ a/2 he decides to buy the whole pack of a cans (instead of buying (x mod a) cans). It makes you, as a marketer, happy since the customer bought more than he wanted initially.
You know that each of the customers that come to your shop can buy any number of cans from l to r inclusive. Can you choose such size of pack a that each customer buys more cans than they wanted initially?
Input
The first line contains a single integer t (1 ≤ t ≤ 1000) — the number of test cases.
The first and only line of each test case contains two integers l and r (1 ≤ l ≤ r ≤ 10^9) — the range of the number of cans customers can buy.
Output
For each test case, print YES if you can choose such size of pack a that each customer buys more cans than they wanted initially. Otherwise, print NO.
You can print each character in any case.
Example
Input
3
3 4
1 2
120 150
Output
YES
NO
YES
Note
In the first test case, you can take, for example, a = 5 as the size of the pack. Then if a customer wants to buy 3 cans, he'll buy 5 instead (3 mod 5 = 3, 5/2 = 2.5). The one who wants 4 cans will also buy 5 cans.
In the second test case, there is no way to choose a.
In the third test case, you can take, for example, a = 80. | instruction | 0 | 76,078 | 10 | 152,156 |
Tags: brute force, constructive algorithms, greedy, math
Correct Solution:
```
for _ in range(int(input())):
a, b = map(int, input().split())
print("YES" if b-a < a else 'NO')
``` | output | 1 | 76,078 | 10 | 152,157 |
Provide tags and a correct Python 3 solution for this coding contest problem.
You got a job as a marketer in a pet shop, and your current task is to boost sales of cat food. One of the strategies is to sell cans of food in packs with discounts.
Suppose you decided to sell packs with a cans in a pack with a discount and some customer wants to buy x cans of cat food. Then he follows a greedy strategy:
* he buys \left⌊ x/a \right⌋ packs with a discount;
* then he wants to buy the remaining (x mod a) cans one by one.
\left⌊ x/a \right⌋ is x divided by a rounded down, x mod a is the remainer of x divided by a.
But customers are greedy in general, so if the customer wants to buy (x mod a) cans one by one and it happens that (x mod a) ≥ a/2 he decides to buy the whole pack of a cans (instead of buying (x mod a) cans). It makes you, as a marketer, happy since the customer bought more than he wanted initially.
You know that each of the customers that come to your shop can buy any number of cans from l to r inclusive. Can you choose such size of pack a that each customer buys more cans than they wanted initially?
Input
The first line contains a single integer t (1 ≤ t ≤ 1000) — the number of test cases.
The first and only line of each test case contains two integers l and r (1 ≤ l ≤ r ≤ 10^9) — the range of the number of cans customers can buy.
Output
For each test case, print YES if you can choose such size of pack a that each customer buys more cans than they wanted initially. Otherwise, print NO.
You can print each character in any case.
Example
Input
3
3 4
1 2
120 150
Output
YES
NO
YES
Note
In the first test case, you can take, for example, a = 5 as the size of the pack. Then if a customer wants to buy 3 cans, he'll buy 5 instead (3 mod 5 = 3, 5/2 = 2.5). The one who wants 4 cans will also buy 5 cans.
In the second test case, there is no way to choose a.
In the third test case, you can take, for example, a = 80. | instruction | 0 | 76,079 | 10 | 152,158 |
Tags: brute force, constructive algorithms, greedy, math
Correct Solution:
```
for t in range(int(input())):
l,r = map(int,input().split())
print('YES' if l*2>r else 'NO')
``` | output | 1 | 76,079 | 10 | 152,159 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
You got a job as a marketer in a pet shop, and your current task is to boost sales of cat food. One of the strategies is to sell cans of food in packs with discounts.
Suppose you decided to sell packs with a cans in a pack with a discount and some customer wants to buy x cans of cat food. Then he follows a greedy strategy:
* he buys \left⌊ x/a \right⌋ packs with a discount;
* then he wants to buy the remaining (x mod a) cans one by one.
\left⌊ x/a \right⌋ is x divided by a rounded down, x mod a is the remainer of x divided by a.
But customers are greedy in general, so if the customer wants to buy (x mod a) cans one by one and it happens that (x mod a) ≥ a/2 he decides to buy the whole pack of a cans (instead of buying (x mod a) cans). It makes you, as a marketer, happy since the customer bought more than he wanted initially.
You know that each of the customers that come to your shop can buy any number of cans from l to r inclusive. Can you choose such size of pack a that each customer buys more cans than they wanted initially?
Input
The first line contains a single integer t (1 ≤ t ≤ 1000) — the number of test cases.
The first and only line of each test case contains two integers l and r (1 ≤ l ≤ r ≤ 10^9) — the range of the number of cans customers can buy.
Output
For each test case, print YES if you can choose such size of pack a that each customer buys more cans than they wanted initially. Otherwise, print NO.
You can print each character in any case.
Example
Input
3
3 4
1 2
120 150
Output
YES
NO
YES
Note
In the first test case, you can take, for example, a = 5 as the size of the pack. Then if a customer wants to buy 3 cans, he'll buy 5 instead (3 mod 5 = 3, 5/2 = 2.5). The one who wants 4 cans will also buy 5 cans.
In the second test case, there is no way to choose a.
In the third test case, you can take, for example, a = 80.
Submitted Solution:
```
t = int(input())
for i in range(t):
l, r = list(map(int, input().split()))
a = r + 1
s = False
if l % a >= a / 2 and r % a >= a / 2:
s = True
else:
s = False
print('NO')
if s:
print('YES')
``` | instruction | 0 | 76,080 | 10 | 152,160 |
Yes | output | 1 | 76,080 | 10 | 152,161 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
You got a job as a marketer in a pet shop, and your current task is to boost sales of cat food. One of the strategies is to sell cans of food in packs with discounts.
Suppose you decided to sell packs with a cans in a pack with a discount and some customer wants to buy x cans of cat food. Then he follows a greedy strategy:
* he buys \left⌊ x/a \right⌋ packs with a discount;
* then he wants to buy the remaining (x mod a) cans one by one.
\left⌊ x/a \right⌋ is x divided by a rounded down, x mod a is the remainer of x divided by a.
But customers are greedy in general, so if the customer wants to buy (x mod a) cans one by one and it happens that (x mod a) ≥ a/2 he decides to buy the whole pack of a cans (instead of buying (x mod a) cans). It makes you, as a marketer, happy since the customer bought more than he wanted initially.
You know that each of the customers that come to your shop can buy any number of cans from l to r inclusive. Can you choose such size of pack a that each customer buys more cans than they wanted initially?
Input
The first line contains a single integer t (1 ≤ t ≤ 1000) — the number of test cases.
The first and only line of each test case contains two integers l and r (1 ≤ l ≤ r ≤ 10^9) — the range of the number of cans customers can buy.
Output
For each test case, print YES if you can choose such size of pack a that each customer buys more cans than they wanted initially. Otherwise, print NO.
You can print each character in any case.
Example
Input
3
3 4
1 2
120 150
Output
YES
NO
YES
Note
In the first test case, you can take, for example, a = 5 as the size of the pack. Then if a customer wants to buy 3 cans, he'll buy 5 instead (3 mod 5 = 3, 5/2 = 2.5). The one who wants 4 cans will also buy 5 cans.
In the second test case, there is no way to choose a.
In the third test case, you can take, for example, a = 80.
Submitted Solution:
```
for i in range(int(input())):
a,b=list(map(int,input().split()))
if a*2<=b:
print("NO")
else:
print("YES")
``` | instruction | 0 | 76,081 | 10 | 152,162 |
Yes | output | 1 | 76,081 | 10 | 152,163 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
You got a job as a marketer in a pet shop, and your current task is to boost sales of cat food. One of the strategies is to sell cans of food in packs with discounts.
Suppose you decided to sell packs with a cans in a pack with a discount and some customer wants to buy x cans of cat food. Then he follows a greedy strategy:
* he buys \left⌊ x/a \right⌋ packs with a discount;
* then he wants to buy the remaining (x mod a) cans one by one.
\left⌊ x/a \right⌋ is x divided by a rounded down, x mod a is the remainer of x divided by a.
But customers are greedy in general, so if the customer wants to buy (x mod a) cans one by one and it happens that (x mod a) ≥ a/2 he decides to buy the whole pack of a cans (instead of buying (x mod a) cans). It makes you, as a marketer, happy since the customer bought more than he wanted initially.
You know that each of the customers that come to your shop can buy any number of cans from l to r inclusive. Can you choose such size of pack a that each customer buys more cans than they wanted initially?
Input
The first line contains a single integer t (1 ≤ t ≤ 1000) — the number of test cases.
The first and only line of each test case contains two integers l and r (1 ≤ l ≤ r ≤ 10^9) — the range of the number of cans customers can buy.
Output
For each test case, print YES if you can choose such size of pack a that each customer buys more cans than they wanted initially. Otherwise, print NO.
You can print each character in any case.
Example
Input
3
3 4
1 2
120 150
Output
YES
NO
YES
Note
In the first test case, you can take, for example, a = 5 as the size of the pack. Then if a customer wants to buy 3 cans, he'll buy 5 instead (3 mod 5 = 3, 5/2 = 2.5). The one who wants 4 cans will also buy 5 cans.
In the second test case, there is no way to choose a.
In the third test case, you can take, for example, a = 80.
Submitted Solution:
```
t=int(input())
while(t>0):
t-=1
a,b=map(int,input().split())
if(a*2<=b):
print("NO")
else:
print("YES")
``` | instruction | 0 | 76,082 | 10 | 152,164 |
Yes | output | 1 | 76,082 | 10 | 152,165 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
You got a job as a marketer in a pet shop, and your current task is to boost sales of cat food. One of the strategies is to sell cans of food in packs with discounts.
Suppose you decided to sell packs with a cans in a pack with a discount and some customer wants to buy x cans of cat food. Then he follows a greedy strategy:
* he buys \left⌊ x/a \right⌋ packs with a discount;
* then he wants to buy the remaining (x mod a) cans one by one.
\left⌊ x/a \right⌋ is x divided by a rounded down, x mod a is the remainer of x divided by a.
But customers are greedy in general, so if the customer wants to buy (x mod a) cans one by one and it happens that (x mod a) ≥ a/2 he decides to buy the whole pack of a cans (instead of buying (x mod a) cans). It makes you, as a marketer, happy since the customer bought more than he wanted initially.
You know that each of the customers that come to your shop can buy any number of cans from l to r inclusive. Can you choose such size of pack a that each customer buys more cans than they wanted initially?
Input
The first line contains a single integer t (1 ≤ t ≤ 1000) — the number of test cases.
The first and only line of each test case contains two integers l and r (1 ≤ l ≤ r ≤ 10^9) — the range of the number of cans customers can buy.
Output
For each test case, print YES if you can choose such size of pack a that each customer buys more cans than they wanted initially. Otherwise, print NO.
You can print each character in any case.
Example
Input
3
3 4
1 2
120 150
Output
YES
NO
YES
Note
In the first test case, you can take, for example, a = 5 as the size of the pack. Then if a customer wants to buy 3 cans, he'll buy 5 instead (3 mod 5 = 3, 5/2 = 2.5). The one who wants 4 cans will also buy 5 cans.
In the second test case, there is no way to choose a.
In the third test case, you can take, for example, a = 80.
Submitted Solution:
```
from math import ceil
def solve(l, r):
if l < ceil((r + 1) / 2):
return False
return True
for _ in range(int(input())):
l, r = list(map(int, input().split()))
if solve(l, r):
print("YES")
else:
print("NO")
``` | instruction | 0 | 76,083 | 10 | 152,166 |
Yes | output | 1 | 76,083 | 10 | 152,167 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
You got a job as a marketer in a pet shop, and your current task is to boost sales of cat food. One of the strategies is to sell cans of food in packs with discounts.
Suppose you decided to sell packs with a cans in a pack with a discount and some customer wants to buy x cans of cat food. Then he follows a greedy strategy:
* he buys \left⌊ x/a \right⌋ packs with a discount;
* then he wants to buy the remaining (x mod a) cans one by one.
\left⌊ x/a \right⌋ is x divided by a rounded down, x mod a is the remainer of x divided by a.
But customers are greedy in general, so if the customer wants to buy (x mod a) cans one by one and it happens that (x mod a) ≥ a/2 he decides to buy the whole pack of a cans (instead of buying (x mod a) cans). It makes you, as a marketer, happy since the customer bought more than he wanted initially.
You know that each of the customers that come to your shop can buy any number of cans from l to r inclusive. Can you choose such size of pack a that each customer buys more cans than they wanted initially?
Input
The first line contains a single integer t (1 ≤ t ≤ 1000) — the number of test cases.
The first and only line of each test case contains two integers l and r (1 ≤ l ≤ r ≤ 10^9) — the range of the number of cans customers can buy.
Output
For each test case, print YES if you can choose such size of pack a that each customer buys more cans than they wanted initially. Otherwise, print NO.
You can print each character in any case.
Example
Input
3
3 4
1 2
120 150
Output
YES
NO
YES
Note
In the first test case, you can take, for example, a = 5 as the size of the pack. Then if a customer wants to buy 3 cans, he'll buy 5 instead (3 mod 5 = 3, 5/2 = 2.5). The one who wants 4 cans will also buy 5 cans.
In the second test case, there is no way to choose a.
In the third test case, you can take, for example, a = 80.
Submitted Solution:
```
t=int(input())
while t>0:
t-=1
l,r=[int(x) for x in input().split()]
if l>1:
print("YES")
else:
print("NO")
``` | instruction | 0 | 76,084 | 10 | 152,168 |
No | output | 1 | 76,084 | 10 | 152,169 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
You got a job as a marketer in a pet shop, and your current task is to boost sales of cat food. One of the strategies is to sell cans of food in packs with discounts.
Suppose you decided to sell packs with a cans in a pack with a discount and some customer wants to buy x cans of cat food. Then he follows a greedy strategy:
* he buys \left⌊ x/a \right⌋ packs with a discount;
* then he wants to buy the remaining (x mod a) cans one by one.
\left⌊ x/a \right⌋ is x divided by a rounded down, x mod a is the remainer of x divided by a.
But customers are greedy in general, so if the customer wants to buy (x mod a) cans one by one and it happens that (x mod a) ≥ a/2 he decides to buy the whole pack of a cans (instead of buying (x mod a) cans). It makes you, as a marketer, happy since the customer bought more than he wanted initially.
You know that each of the customers that come to your shop can buy any number of cans from l to r inclusive. Can you choose such size of pack a that each customer buys more cans than they wanted initially?
Input
The first line contains a single integer t (1 ≤ t ≤ 1000) — the number of test cases.
The first and only line of each test case contains two integers l and r (1 ≤ l ≤ r ≤ 10^9) — the range of the number of cans customers can buy.
Output
For each test case, print YES if you can choose such size of pack a that each customer buys more cans than they wanted initially. Otherwise, print NO.
You can print each character in any case.
Example
Input
3
3 4
1 2
120 150
Output
YES
NO
YES
Note
In the first test case, you can take, for example, a = 5 as the size of the pack. Then if a customer wants to buy 3 cans, he'll buy 5 instead (3 mod 5 = 3, 5/2 = 2.5). The one who wants 4 cans will also buy 5 cans.
In the second test case, there is no way to choose a.
In the third test case, you can take, for example, a = 80.
Submitted Solution:
```
import time,math as mt,bisect as bs,sys
from sys import stdin,stdout
from collections import deque
from fractions import Fraction
from collections import Counter
from collections import OrderedDict
pi=3.14159265358979323846264338327950
def II(): # to take integer input
return int(stdin.readline())
def IP(): # to take tuple as input
return map(int,stdin.readline().split())
def L(): # to take list as input
return list(map(int,stdin.readline().split()))
def P(x): # to print integer,list,string etc..
return stdout.write(str(x)+"\n")
def PI(x,y): # to print tuple separatedly
return stdout.write(str(x)+" "+str(y)+"\n")
def lcm(a,b): # to calculate lcm
return (a*b)//gcd(a,b)
def gcd(a,b): # to calculate gcd
if a==0:
return b
elif b==0:
return a
if a>b:
return gcd(a%b,b)
else:
return gcd(a,b%a)
def bfs(adj,v): # a schema of bfs
visited=[False]*(v+1)
q=deque()
while q:
pass
def sieve():
li=[True]*(2*(10**5)+5)
li[0],li[1]=False,False
for i in range(2,len(li),1):
if li[i]==True:
for j in range(i*i,len(li),i):
li[j]=False
prime=[]
for i in range((2*(10**5)+5)):
if li[i]==True:
prime.append(i)
return prime
def setBit(n):
count=0
while n!=0:
n=n&(n-1)
count+=1
return count
mx=10**7
spf=[mx]*(mx+1)
def SPF():
spf[1]=1
for i in range(2,mx+1):
if spf[i]==mx:
spf[i]=i
for j in range(i*i,mx+1,i):
if i<spf[j]:
spf[j]=i
return
def readTree(n,e): # to read tree
adj=[set() for i in range(n+1)]
for i in range(e):
u1,u2=IP()
adj[u1].add(u2)
return adj
#####################################################################################
mod=10**9+7
def solve():
l,r=IP()
x=2*l-1
if x>=l and x<=r:
print("NO")
return
print("YES")
return
return
t=II()
for i in range(t):
solve()
#######
#
#
####### # # # #### # # #
# # # # # # # # # # #
# #### # # #### #### # #
###### # # #### # # # # #
# ``````¶0````1¶1_```````````````````````````````````````
# ```````¶¶¶0_`_¶¶¶0011100¶¶¶¶¶¶¶001_````````````````````
# ````````¶¶¶¶¶00¶¶¶¶¶¶¶¶¶¶¶¶¶¶¶¶¶¶¶¶¶¶0_````````````````
# `````1_``¶¶00¶0000000000000000000000¶¶¶¶0_`````````````
# `````_¶¶_`0¶000000000000000000000000000¶¶¶¶¶1``````````
# ```````¶¶¶00¶00000000000000000000000000000¶¶¶_`````````
# ````````_¶¶00000000000000000000¶¶00000000000¶¶`````````
# `````_0011¶¶¶¶¶000000000000¶¶00¶¶0¶¶00000000¶¶_````````
# ```````_¶¶¶¶¶¶¶00000000000¶¶¶¶0¶¶¶¶¶00000000¶¶1````````
# ``````````1¶¶¶¶¶000000¶¶0¶¶¶¶¶¶¶¶¶¶¶¶0000000¶¶¶````````
# ```````````¶¶¶0¶000¶00¶0¶¶`_____`__1¶0¶¶00¶00¶¶````````
# ```````````¶¶¶¶¶00¶00¶10¶0``_1111_`_¶¶0000¶0¶¶¶````````
# ``````````1¶¶¶¶¶00¶0¶¶_¶¶1`_¶_1_0_`1¶¶_0¶0¶¶0¶¶````````
# ````````1¶¶¶¶¶¶¶0¶¶0¶0_0¶``100111``_¶1_0¶0¶¶_1¶````````
# ```````1¶¶¶¶00¶¶¶¶¶¶¶010¶``1111111_0¶11¶¶¶¶¶_10````````
# ```````0¶¶¶¶__10¶¶¶¶¶100¶¶¶0111110¶¶¶1__¶¶¶¶`__````````
# ```````¶¶¶¶0`__0¶¶0¶¶_¶¶¶_11````_0¶¶0`_1¶¶¶¶```````````
# ```````¶¶¶00`__0¶¶_00`_0_``````````1_``¶0¶¶_```````````
# ``````1¶1``¶¶``1¶¶_11``````````````````¶`¶¶````````````
# ``````1_``¶0_¶1`0¶_`_``````````_``````1_`¶1````````````
# ``````````_`1¶00¶¶_````_````__`1`````__`_¶`````````````
# ````````````¶1`0¶¶_`````````_11_`````_``_``````````````
# `````````¶¶¶¶000¶¶_1```````_____```_1``````````````````
# `````````¶¶¶¶¶¶¶¶¶¶¶¶0_``````_````_1111__``````````````
# `````````¶¶¶¶¶¶¶¶¶¶¶¶¶¶¶01_`````_11____1111_```````````
# `````````¶¶0¶0¶¶¶¶¶¶¶¶¶¶¶¶¶¶¶1101_______11¶_```````````
# ``````_¶¶¶0000000¶¶¶¶¶¶¶¶¶¶¶¶¶¶¶¶¶¶¶0¶0¶¶¶1````````````
# `````0¶¶0000000¶¶¶¶¶¶¶¶¶¶¶¶¶¶¶¶¶¶¶¶¶¶¶¶¶¶1`````````````
# ````0¶0000000¶¶0_````_011_10¶110¶01_1¶¶¶0````_100¶001_`
# ```1¶0000000¶0_``__`````````_`````````0¶_``_00¶¶010¶001
# ```¶¶00000¶¶1``_01``_11____``1_``_`````¶¶0100¶1```_00¶1
# ``1¶¶00000¶_``_¶_`_101_``_`__````__````_0000001100¶¶¶0`
# ``¶¶¶0000¶1_`_¶``__0_``````_1````_1_````1¶¶¶0¶¶¶¶¶¶0```
# `_¶¶¶¶00¶0___01_10¶_``__````1`````11___`1¶¶¶01_````````
# `1¶¶¶¶¶0¶0`__01¶¶¶0````1_```11``___1_1__11¶000`````````
# `1¶¶¶¶¶¶¶1_1_01__`01```_1```_1__1_11___1_``00¶1````````
# ``¶¶¶¶¶¶¶0`__10__000````1____1____1___1_```10¶0_```````
# ``0¶¶¶¶¶¶¶1___0000000```11___1__`_0111_```000¶01```````
# ```¶¶¶00000¶¶¶¶¶¶¶¶¶01___1___00_1¶¶¶`_``1¶¶10¶¶0```````
# ```1010000¶000¶¶0100_11__1011000¶¶0¶1_10¶¶¶_0¶¶00``````
# 10¶000000000¶0________0¶000000¶¶0000¶¶¶¶000_0¶0¶00`````
# ¶¶¶¶¶¶0000¶¶¶¶_`___`_0¶¶¶¶¶¶¶00000000000000_0¶00¶01````
# ¶¶¶¶¶0¶¶¶¶¶¶¶¶¶_``_1¶¶¶00000000000000000000_0¶000¶01```
# 1__```1¶¶¶¶¶¶¶¶¶00¶¶¶¶00000000000000000000¶_0¶0000¶0_``
# ```````¶¶¶¶¶¶¶¶¶¶¶¶¶¶¶00000000000000000000010¶00000¶¶_`
# ```````0¶¶¶¶¶¶¶¶¶¶¶¶¶¶00000000000000000000¶10¶¶0¶¶¶¶¶0`
# ````````¶¶¶¶¶¶¶¶¶¶0¶¶¶00000000000000000000010¶¶¶0011```
# ````````1¶¶¶¶¶¶¶¶¶¶0¶¶¶0000000000000000000¶100__1_`````
# `````````¶¶¶¶¶¶¶¶¶¶¶¶¶¶¶000000000000000000¶11``_1``````
# `````````1¶¶¶¶¶¶¶¶¶¶¶0¶¶¶00000000000000000¶11___1_`````
# ``````````¶¶¶¶¶¶0¶0¶¶¶¶¶¶¶0000000000000000¶11__``1_````
# ``````````¶¶¶¶¶¶¶0¶¶¶0¶¶¶¶¶000000000000000¶1__````__```
# ``````````¶¶¶¶¶¶¶¶0¶¶¶¶¶¶¶¶¶0000000000000000__`````11``
# `````````_¶¶¶¶¶¶¶¶¶000¶¶¶¶¶¶¶¶000000000000011_``_1¶¶¶0`
# `````````_¶¶¶¶¶¶0¶¶000000¶¶¶¶¶¶¶000000000000100¶¶¶¶0_`_
# `````````1¶¶¶¶¶0¶¶¶000000000¶¶¶¶¶¶000000000¶00¶¶01`````
# `````````¶¶¶¶¶0¶0¶¶¶0000000000000¶0¶00000000011_``````_
# ````````1¶¶0¶¶¶0¶¶¶¶¶¶¶000000000000000000000¶11___11111
# ````````¶¶¶¶0¶¶¶¶¶00¶¶¶¶¶¶000000000000000000¶011111111_
# ```````_¶¶¶¶¶¶¶¶¶0000000¶0¶00000000000000000¶01_1111111
# ```````0¶¶¶¶¶¶¶¶¶000000000000000000000000000¶01___`````
# ```````¶¶¶¶¶¶0¶¶¶000000000000000000000000000¶01___1````
# ``````_¶¶¶¶¶¶¶¶¶00000000000000000000000000000011_111```
# ``````0¶¶0¶¶¶0¶¶0000000000000000000000000000¶01`1_11_``
# ``````¶¶¶¶¶¶0¶¶¶0000000000000000000000000000001`_0_11_`
# ``````¶¶¶¶¶¶¶¶¶00000000000000000000000000000¶01``_0_11`
# ``````¶¶¶¶0¶¶¶¶00000000000000000000000000000001```_1_11
``` | instruction | 0 | 76,085 | 10 | 152,170 |
No | output | 1 | 76,085 | 10 | 152,171 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
You got a job as a marketer in a pet shop, and your current task is to boost sales of cat food. One of the strategies is to sell cans of food in packs with discounts.
Suppose you decided to sell packs with a cans in a pack with a discount and some customer wants to buy x cans of cat food. Then he follows a greedy strategy:
* he buys \left⌊ x/a \right⌋ packs with a discount;
* then he wants to buy the remaining (x mod a) cans one by one.
\left⌊ x/a \right⌋ is x divided by a rounded down, x mod a is the remainer of x divided by a.
But customers are greedy in general, so if the customer wants to buy (x mod a) cans one by one and it happens that (x mod a) ≥ a/2 he decides to buy the whole pack of a cans (instead of buying (x mod a) cans). It makes you, as a marketer, happy since the customer bought more than he wanted initially.
You know that each of the customers that come to your shop can buy any number of cans from l to r inclusive. Can you choose such size of pack a that each customer buys more cans than they wanted initially?
Input
The first line contains a single integer t (1 ≤ t ≤ 1000) — the number of test cases.
The first and only line of each test case contains two integers l and r (1 ≤ l ≤ r ≤ 10^9) — the range of the number of cans customers can buy.
Output
For each test case, print YES if you can choose such size of pack a that each customer buys more cans than they wanted initially. Otherwise, print NO.
You can print each character in any case.
Example
Input
3
3 4
1 2
120 150
Output
YES
NO
YES
Note
In the first test case, you can take, for example, a = 5 as the size of the pack. Then if a customer wants to buy 3 cans, he'll buy 5 instead (3 mod 5 = 3, 5/2 = 2.5). The one who wants 4 cans will also buy 5 cans.
In the second test case, there is no way to choose a.
In the third test case, you can take, for example, a = 80.
Submitted Solution:
```
import sys
import math
input=sys.stdin.readline
t=int(input())
for w in range(t):
l,r=(int(i) for i in input().split())
if(l==1 and r==2):
print("NO")
else:
if(l>=math.ceil(r/2)):
print("YES")
else:
print("NO")
``` | instruction | 0 | 76,086 | 10 | 152,172 |
No | output | 1 | 76,086 | 10 | 152,173 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
You got a job as a marketer in a pet shop, and your current task is to boost sales of cat food. One of the strategies is to sell cans of food in packs with discounts.
Suppose you decided to sell packs with a cans in a pack with a discount and some customer wants to buy x cans of cat food. Then he follows a greedy strategy:
* he buys \left⌊ x/a \right⌋ packs with a discount;
* then he wants to buy the remaining (x mod a) cans one by one.
\left⌊ x/a \right⌋ is x divided by a rounded down, x mod a is the remainer of x divided by a.
But customers are greedy in general, so if the customer wants to buy (x mod a) cans one by one and it happens that (x mod a) ≥ a/2 he decides to buy the whole pack of a cans (instead of buying (x mod a) cans). It makes you, as a marketer, happy since the customer bought more than he wanted initially.
You know that each of the customers that come to your shop can buy any number of cans from l to r inclusive. Can you choose such size of pack a that each customer buys more cans than they wanted initially?
Input
The first line contains a single integer t (1 ≤ t ≤ 1000) — the number of test cases.
The first and only line of each test case contains two integers l and r (1 ≤ l ≤ r ≤ 10^9) — the range of the number of cans customers can buy.
Output
For each test case, print YES if you can choose such size of pack a that each customer buys more cans than they wanted initially. Otherwise, print NO.
You can print each character in any case.
Example
Input
3
3 4
1 2
120 150
Output
YES
NO
YES
Note
In the first test case, you can take, for example, a = 5 as the size of the pack. Then if a customer wants to buy 3 cans, he'll buy 5 instead (3 mod 5 = 3, 5/2 = 2.5). The one who wants 4 cans will also buy 5 cans.
In the second test case, there is no way to choose a.
In the third test case, you can take, for example, a = 80.
Submitted Solution:
```
time = int(input())
for i in range(time):
left, right = map(int, input().split())
if (left % (right+1)) > right+1/2:
print("YES")
else:
print("NO")
``` | instruction | 0 | 76,087 | 10 | 152,174 |
No | output | 1 | 76,087 | 10 | 152,175 |
Provide a correct Python 3 solution for this coding contest problem.
E869120 has A 1-yen coins and infinitely many 500-yen coins.
Determine if he can pay exactly N yen using only these coins.
Constraints
* N is an integer between 1 and 10000 (inclusive).
* A is an integer between 0 and 1000 (inclusive).
Input
Input is given from Standard Input in the following format:
N
A
Output
If E869120 can pay exactly N yen using only his 1-yen and 500-yen coins, print `Yes`; otherwise, print `No`.
Examples
Input
2018
218
Output
Yes
Input
2763
0
Output
No
Input
37
514
Output
Yes | instruction | 0 | 76,543 | 10 | 153,086 |
"Correct Solution:
```
def main():
print('YNeos'[int(input()) % 500 > int(input())::2])
main()
``` | output | 1 | 76,543 | 10 | 153,087 |
Provide a correct Python 3 solution for this coding contest problem.
E869120 has A 1-yen coins and infinitely many 500-yen coins.
Determine if he can pay exactly N yen using only these coins.
Constraints
* N is an integer between 1 and 10000 (inclusive).
* A is an integer between 0 and 1000 (inclusive).
Input
Input is given from Standard Input in the following format:
N
A
Output
If E869120 can pay exactly N yen using only his 1-yen and 500-yen coins, print `Yes`; otherwise, print `No`.
Examples
Input
2018
218
Output
Yes
Input
2763
0
Output
No
Input
37
514
Output
Yes | instruction | 0 | 76,544 | 10 | 153,088 |
"Correct Solution:
```
n=int(input())
a=int(input())
print(['No','Yes'][n-(n//500)/(1/500)-a<=0])
``` | output | 1 | 76,544 | 10 | 153,089 |
Provide a correct Python 3 solution for this coding contest problem.
E869120 has A 1-yen coins and infinitely many 500-yen coins.
Determine if he can pay exactly N yen using only these coins.
Constraints
* N is an integer between 1 and 10000 (inclusive).
* A is an integer between 0 and 1000 (inclusive).
Input
Input is given from Standard Input in the following format:
N
A
Output
If E869120 can pay exactly N yen using only his 1-yen and 500-yen coins, print `Yes`; otherwise, print `No`.
Examples
Input
2018
218
Output
Yes
Input
2763
0
Output
No
Input
37
514
Output
Yes | instruction | 0 | 76,545 | 10 | 153,090 |
"Correct Solution:
```
N = int(input())
A = int(input())
print("Yes" if (A >= N % 500) else "No")
``` | output | 1 | 76,545 | 10 | 153,091 |
Provide a correct Python 3 solution for this coding contest problem.
E869120 has A 1-yen coins and infinitely many 500-yen coins.
Determine if he can pay exactly N yen using only these coins.
Constraints
* N is an integer between 1 and 10000 (inclusive).
* A is an integer between 0 and 1000 (inclusive).
Input
Input is given from Standard Input in the following format:
N
A
Output
If E869120 can pay exactly N yen using only his 1-yen and 500-yen coins, print `Yes`; otherwise, print `No`.
Examples
Input
2018
218
Output
Yes
Input
2763
0
Output
No
Input
37
514
Output
Yes | instruction | 0 | 76,546 | 10 | 153,092 |
"Correct Solution:
```
n=int(input())
a=int(input())
print(("No","Yes")[n%500<=a])
``` | output | 1 | 76,546 | 10 | 153,093 |
Provide a correct Python 3 solution for this coding contest problem.
E869120 has A 1-yen coins and infinitely many 500-yen coins.
Determine if he can pay exactly N yen using only these coins.
Constraints
* N is an integer between 1 and 10000 (inclusive).
* A is an integer between 0 and 1000 (inclusive).
Input
Input is given from Standard Input in the following format:
N
A
Output
If E869120 can pay exactly N yen using only his 1-yen and 500-yen coins, print `Yes`; otherwise, print `No`.
Examples
Input
2018
218
Output
Yes
Input
2763
0
Output
No
Input
37
514
Output
Yes | instruction | 0 | 76,547 | 10 | 153,094 |
"Correct Solution:
```
n = int(input())
a = int(input())
print("Yes" if n%500 <= a else "No")
``` | output | 1 | 76,547 | 10 | 153,095 |
Provide a correct Python 3 solution for this coding contest problem.
E869120 has A 1-yen coins and infinitely many 500-yen coins.
Determine if he can pay exactly N yen using only these coins.
Constraints
* N is an integer between 1 and 10000 (inclusive).
* A is an integer between 0 and 1000 (inclusive).
Input
Input is given from Standard Input in the following format:
N
A
Output
If E869120 can pay exactly N yen using only his 1-yen and 500-yen coins, print `Yes`; otherwise, print `No`.
Examples
Input
2018
218
Output
Yes
Input
2763
0
Output
No
Input
37
514
Output
Yes | instruction | 0 | 76,548 | 10 | 153,096 |
"Correct Solution:
```
n = int(input())
a = int(input())
print('Yes' if n %500 <= a else 'No')
``` | output | 1 | 76,548 | 10 | 153,097 |
Provide a correct Python 3 solution for this coding contest problem.
E869120 has A 1-yen coins and infinitely many 500-yen coins.
Determine if he can pay exactly N yen using only these coins.
Constraints
* N is an integer between 1 and 10000 (inclusive).
* A is an integer between 0 and 1000 (inclusive).
Input
Input is given from Standard Input in the following format:
N
A
Output
If E869120 can pay exactly N yen using only his 1-yen and 500-yen coins, print `Yes`; otherwise, print `No`.
Examples
Input
2018
218
Output
Yes
Input
2763
0
Output
No
Input
37
514
Output
Yes | instruction | 0 | 76,549 | 10 | 153,098 |
"Correct Solution:
```
n=int(input())
print("No" if n%500>int(input()) else "Yes")
``` | output | 1 | 76,549 | 10 | 153,099 |
Provide a correct Python 3 solution for this coding contest problem.
E869120 has A 1-yen coins and infinitely many 500-yen coins.
Determine if he can pay exactly N yen using only these coins.
Constraints
* N is an integer between 1 and 10000 (inclusive).
* A is an integer between 0 and 1000 (inclusive).
Input
Input is given from Standard Input in the following format:
N
A
Output
If E869120 can pay exactly N yen using only his 1-yen and 500-yen coins, print `Yes`; otherwise, print `No`.
Examples
Input
2018
218
Output
Yes
Input
2763
0
Output
No
Input
37
514
Output
Yes | instruction | 0 | 76,550 | 10 | 153,100 |
"Correct Solution:
```
N = int(input()) % 500
A = int(input())
print('Yes' if A >= N else 'No')
``` | output | 1 | 76,550 | 10 | 153,101 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
E869120 has A 1-yen coins and infinitely many 500-yen coins.
Determine if he can pay exactly N yen using only these coins.
Constraints
* N is an integer between 1 and 10000 (inclusive).
* A is an integer between 0 and 1000 (inclusive).
Input
Input is given from Standard Input in the following format:
N
A
Output
If E869120 can pay exactly N yen using only his 1-yen and 500-yen coins, print `Yes`; otherwise, print `No`.
Examples
Input
2018
218
Output
Yes
Input
2763
0
Output
No
Input
37
514
Output
Yes
Submitted Solution:
```
N=int(input())
A=int(input())
if N%500>A:
print("No")
else:
print("Yes")
``` | instruction | 0 | 76,551 | 10 | 153,102 |
Yes | output | 1 | 76,551 | 10 | 153,103 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
E869120 has A 1-yen coins and infinitely many 500-yen coins.
Determine if he can pay exactly N yen using only these coins.
Constraints
* N is an integer between 1 and 10000 (inclusive).
* A is an integer between 0 and 1000 (inclusive).
Input
Input is given from Standard Input in the following format:
N
A
Output
If E869120 can pay exactly N yen using only his 1-yen and 500-yen coins, print `Yes`; otherwise, print `No`.
Examples
Input
2018
218
Output
Yes
Input
2763
0
Output
No
Input
37
514
Output
Yes
Submitted Solution:
```
N = int(input())
A = int(input())
print(["Yes", "No"][N % 500 > A])
``` | instruction | 0 | 76,552 | 10 | 153,104 |
Yes | output | 1 | 76,552 | 10 | 153,105 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
E869120 has A 1-yen coins and infinitely many 500-yen coins.
Determine if he can pay exactly N yen using only these coins.
Constraints
* N is an integer between 1 and 10000 (inclusive).
* A is an integer between 0 and 1000 (inclusive).
Input
Input is given from Standard Input in the following format:
N
A
Output
If E869120 can pay exactly N yen using only his 1-yen and 500-yen coins, print `Yes`; otherwise, print `No`.
Examples
Input
2018
218
Output
Yes
Input
2763
0
Output
No
Input
37
514
Output
Yes
Submitted Solution:
```
n=int(input())
a=int(input())
print('Yes' if n%500<=a else 'No');
``` | instruction | 0 | 76,553 | 10 | 153,106 |
Yes | output | 1 | 76,553 | 10 | 153,107 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
E869120 has A 1-yen coins and infinitely many 500-yen coins.
Determine if he can pay exactly N yen using only these coins.
Constraints
* N is an integer between 1 and 10000 (inclusive).
* A is an integer between 0 and 1000 (inclusive).
Input
Input is given from Standard Input in the following format:
N
A
Output
If E869120 can pay exactly N yen using only his 1-yen and 500-yen coins, print `Yes`; otherwise, print `No`.
Examples
Input
2018
218
Output
Yes
Input
2763
0
Output
No
Input
37
514
Output
Yes
Submitted Solution:
```
n, a = (int(input()) for _ in range(2))
print('No' if n%500 >a else 'Yes')
``` | instruction | 0 | 76,554 | 10 | 153,108 |
Yes | output | 1 | 76,554 | 10 | 153,109 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
E869120 has A 1-yen coins and infinitely many 500-yen coins.
Determine if he can pay exactly N yen using only these coins.
Constraints
* N is an integer between 1 and 10000 (inclusive).
* A is an integer between 0 and 1000 (inclusive).
Input
Input is given from Standard Input in the following format:
N
A
Output
If E869120 can pay exactly N yen using only his 1-yen and 500-yen coins, print `Yes`; otherwise, print `No`.
Examples
Input
2018
218
Output
Yes
Input
2763
0
Output
No
Input
37
514
Output
Yes
Submitted Solution:
```
c1 = list(map(int, input().split()))
c2 = list(map(int, input().split()))
c3 = list(map(int, input().split()))
c = c1 + c2 + c3
if sum(c) % 3 == 0 and c[0] + c[4] + c[8] == c[1] + c[3] + c[8]:
print("Yes")
else:
print("No")
``` | instruction | 0 | 76,555 | 10 | 153,110 |
No | output | 1 | 76,555 | 10 | 153,111 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
E869120 has A 1-yen coins and infinitely many 500-yen coins.
Determine if he can pay exactly N yen using only these coins.
Constraints
* N is an integer between 1 and 10000 (inclusive).
* A is an integer between 0 and 1000 (inclusive).
Input
Input is given from Standard Input in the following format:
N
A
Output
If E869120 can pay exactly N yen using only his 1-yen and 500-yen coins, print `Yes`; otherwise, print `No`.
Examples
Input
2018
218
Output
Yes
Input
2763
0
Output
No
Input
37
514
Output
Yes
Submitted Solution:
```
n,a=map(int,input().split())
b=n%500
if a>=b:
print("Yes")
else:
print("No")
``` | instruction | 0 | 76,556 | 10 | 153,112 |
No | output | 1 | 76,556 | 10 | 153,113 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
E869120 has A 1-yen coins and infinitely many 500-yen coins.
Determine if he can pay exactly N yen using only these coins.
Constraints
* N is an integer between 1 and 10000 (inclusive).
* A is an integer between 0 and 1000 (inclusive).
Input
Input is given from Standard Input in the following format:
N
A
Output
If E869120 can pay exactly N yen using only his 1-yen and 500-yen coins, print `Yes`; otherwise, print `No`.
Examples
Input
2018
218
Output
Yes
Input
2763
0
Output
No
Input
37
514
Output
Yes
Submitted Solution:
```
n=int(input())
a=int(input())
n=n-a
if n//500==0:
print("YES")
else :
print("NO")
``` | instruction | 0 | 76,557 | 10 | 153,114 |
No | output | 1 | 76,557 | 10 | 153,115 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
E869120 has A 1-yen coins and infinitely many 500-yen coins.
Determine if he can pay exactly N yen using only these coins.
Constraints
* N is an integer between 1 and 10000 (inclusive).
* A is an integer between 0 and 1000 (inclusive).
Input
Input is given from Standard Input in the following format:
N
A
Output
If E869120 can pay exactly N yen using only his 1-yen and 500-yen coins, print `Yes`; otherwise, print `No`.
Examples
Input
2018
218
Output
Yes
Input
2763
0
Output
No
Input
37
514
Output
Yes
Submitted Solution:
```
N = int(input())
A = int(input())
tmp = N // 500
for a in range(1, A+1):
total = a*1 + tmp*500
if total == N:
print('YES')
exit()
print('NO')
``` | instruction | 0 | 76,558 | 10 | 153,116 |
No | output | 1 | 76,558 | 10 | 153,117 |
Provide tags and a correct Python 3 solution for this coding contest problem.
Tenten runs a weapon shop for ninjas. Today she is willing to sell n shurikens which cost 1, 2, ..., n ryo (local currency). During a day, Tenten will place the shurikens onto the showcase, which is empty at the beginning of the day. Her job is fairly simple: sometimes Tenten places another shuriken (from the available shurikens) on the showcase, and sometimes a ninja comes in and buys a shuriken from the showcase. Since ninjas are thrifty, they always buy the cheapest shuriken from the showcase.
Tenten keeps a record for all events, and she ends up with a list of the following types of records:
* + means that she placed another shuriken on the showcase;
* - x means that the shuriken of price x was bought.
Today was a lucky day, and all shurikens were bought. Now Tenten wonders if her list is consistent, and what could be a possible order of placing the shurikens on the showcase. Help her to find this out!
Input
The first line contains the only integer n (1≤ n≤ 10^5) standing for the number of shurikens.
The following 2n lines describe the events in the format described above. It's guaranteed that there are exactly n events of the first type, and each price from 1 to n occurs exactly once in the events of the second type.
Output
If the list is consistent, print "YES". Otherwise (that is, if the list is contradictory and there is no valid order of shurikens placement), print "NO".
In the first case the second line must contain n space-separated integers denoting the prices of shurikens in order they were placed. If there are multiple answers, print any.
Examples
Input
4
+
+
- 2
+
- 3
+
- 1
- 4
Output
YES
4 2 3 1
Input
1
- 1
+
Output
NO
Input
3
+
+
+
- 2
- 1
- 3
Output
NO
Note
In the first example Tenten first placed shurikens with prices 4 and 2. After this a customer came in and bought the cheapest shuriken which costed 2. Next, Tenten added a shuriken with price 3 on the showcase to the already placed 4-ryo. Then a new customer bought this 3-ryo shuriken. After this she added a 1-ryo shuriken. Finally, the last two customers bought shurikens 1 and 4, respectively. Note that the order [2, 4, 3, 1] is also valid.
In the second example the first customer bought a shuriken before anything was placed, which is clearly impossible.
In the third example Tenten put all her shurikens onto the showcase, after which a customer came in and bought a shuriken with price 2. This is impossible since the shuriken was not the cheapest, we know that the 1-ryo shuriken was also there. | instruction | 0 | 76,904 | 10 | 153,808 |
Tags: data structures, greedy, implementation
Correct Solution:
```
import sys
readline = sys.stdin.readline
from heapq import heappop as hpp, heappush as hp
N = int(readline())
ev = [None]*(2*N)
pl = []
ans = 'YES'
for i in range(2*N):
s = readline().strip()
if s[0] == '+':
pl.append(i)
else:
if not pl:
ans = 'NO'
else:
b = int(s.split()[1])
ev[i] = b
ev[pl.pop()] = -b
if ans == 'NO':
print(ans)
else:
Q = []
for i in ev:
if i < 0:
i = -i
hp(Q, i)
else:
if i != hpp(Q):
ans = 'NO'
break
print(ans)
if ans == 'YES':
print(*[-i for i in ev if i < 0])
``` | output | 1 | 76,904 | 10 | 153,809 |
Provide tags and a correct Python 3 solution for this coding contest problem.
Tenten runs a weapon shop for ninjas. Today she is willing to sell n shurikens which cost 1, 2, ..., n ryo (local currency). During a day, Tenten will place the shurikens onto the showcase, which is empty at the beginning of the day. Her job is fairly simple: sometimes Tenten places another shuriken (from the available shurikens) on the showcase, and sometimes a ninja comes in and buys a shuriken from the showcase. Since ninjas are thrifty, they always buy the cheapest shuriken from the showcase.
Tenten keeps a record for all events, and she ends up with a list of the following types of records:
* + means that she placed another shuriken on the showcase;
* - x means that the shuriken of price x was bought.
Today was a lucky day, and all shurikens were bought. Now Tenten wonders if her list is consistent, and what could be a possible order of placing the shurikens on the showcase. Help her to find this out!
Input
The first line contains the only integer n (1≤ n≤ 10^5) standing for the number of shurikens.
The following 2n lines describe the events in the format described above. It's guaranteed that there are exactly n events of the first type, and each price from 1 to n occurs exactly once in the events of the second type.
Output
If the list is consistent, print "YES". Otherwise (that is, if the list is contradictory and there is no valid order of shurikens placement), print "NO".
In the first case the second line must contain n space-separated integers denoting the prices of shurikens in order they were placed. If there are multiple answers, print any.
Examples
Input
4
+
+
- 2
+
- 3
+
- 1
- 4
Output
YES
4 2 3 1
Input
1
- 1
+
Output
NO
Input
3
+
+
+
- 2
- 1
- 3
Output
NO
Note
In the first example Tenten first placed shurikens with prices 4 and 2. After this a customer came in and bought the cheapest shuriken which costed 2. Next, Tenten added a shuriken with price 3 on the showcase to the already placed 4-ryo. Then a new customer bought this 3-ryo shuriken. After this she added a 1-ryo shuriken. Finally, the last two customers bought shurikens 1 and 4, respectively. Note that the order [2, 4, 3, 1] is also valid.
In the second example the first customer bought a shuriken before anything was placed, which is clearly impossible.
In the third example Tenten put all her shurikens onto the showcase, after which a customer came in and bought a shuriken with price 2. This is impossible since the shuriken was not the cheapest, we know that the 1-ryo shuriken was also there. | instruction | 0 | 76,905 | 10 | 153,810 |
Tags: data structures, greedy, implementation
Correct Solution:
```
import sys, io, os
BUFSIZE = 8192
class FastIO(io.IOBase):
newlines = 0
def __init__(self, file):
self._fd = file.fileno()
self.buffer = io.BytesIO()
self.writable = "x" in file.mode or "r" not in file.mode
self.write = self.buffer.write if self.writable else None
def read(self):
while True:
b = os.read(self._fd, max(os.fstat(self._fd).st_size, BUFSIZE))
if not b:
break
ptr = self.buffer.tell()
self.buffer.seek(0, 2), self.buffer.write(b), self.buffer.seek(ptr)
self.newlines = 0
return self.buffer.read()
def readline(self):
while self.newlines == 0:
b = os.read(self._fd, max(os.fstat(self._fd).st_size, BUFSIZE))
self.newlines = b.count(b"\n") + (not b)
ptr = self.buffer.tell()
self.buffer.seek(0, 2), self.buffer.write(b), self.buffer.seek(ptr)
self.newlines -= 1
return self.buffer.readline()
def flush(self):
if self.writable:
os.write(self._fd, self.buffer.getvalue())
self.buffer.truncate(0), self.buffer.seek(0)
class IOWrapper(io.IOBase):
def __init__(self, file):
self.buffer = FastIO(file)
self.flush = self.buffer.flush
self.writable = self.buffer.writable
self.write = lambda s: self.buffer.write(s.encode("ascii"))
self.read = lambda: self.buffer.read().decode("ascii")
self.readline = lambda: self.buffer.readline().decode("ascii")
def print(*args, **kwargs):
"""Prints the values to a stream, or to sys.stdout by default."""
sep, file = kwargs.pop("sep", " "), 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", "\n"))
if kwargs.pop("flush", False):
file.flush()
sys.stdin, sys.stdout = IOWrapper(sys.stdin), IOWrapper(sys.stdout)
input = lambda: sys.stdin.readline().rstrip("\r\n")
#endregion
from heapq import heappush, heappop
n = int(input())
ops = [input() for _ in range(n + n)]
queue = []
ans = []
for i in range(2*n - 1, -1, -1):
if ops[i][0] == '+':
if not queue:
print('NO')
exit(0)
ans.append(heappop(queue))
else:
val = int(ops[i].split()[1])
if queue and val > queue[0]:
print('NO')
exit(0)
heappush(queue, val)
print('YES')
print(' '.join(str(x) for x in reversed(ans)))
``` | output | 1 | 76,905 | 10 | 153,811 |
Provide tags and a correct Python 3 solution for this coding contest problem.
Tenten runs a weapon shop for ninjas. Today she is willing to sell n shurikens which cost 1, 2, ..., n ryo (local currency). During a day, Tenten will place the shurikens onto the showcase, which is empty at the beginning of the day. Her job is fairly simple: sometimes Tenten places another shuriken (from the available shurikens) on the showcase, and sometimes a ninja comes in and buys a shuriken from the showcase. Since ninjas are thrifty, they always buy the cheapest shuriken from the showcase.
Tenten keeps a record for all events, and she ends up with a list of the following types of records:
* + means that she placed another shuriken on the showcase;
* - x means that the shuriken of price x was bought.
Today was a lucky day, and all shurikens were bought. Now Tenten wonders if her list is consistent, and what could be a possible order of placing the shurikens on the showcase. Help her to find this out!
Input
The first line contains the only integer n (1≤ n≤ 10^5) standing for the number of shurikens.
The following 2n lines describe the events in the format described above. It's guaranteed that there are exactly n events of the first type, and each price from 1 to n occurs exactly once in the events of the second type.
Output
If the list is consistent, print "YES". Otherwise (that is, if the list is contradictory and there is no valid order of shurikens placement), print "NO".
In the first case the second line must contain n space-separated integers denoting the prices of shurikens in order they were placed. If there are multiple answers, print any.
Examples
Input
4
+
+
- 2
+
- 3
+
- 1
- 4
Output
YES
4 2 3 1
Input
1
- 1
+
Output
NO
Input
3
+
+
+
- 2
- 1
- 3
Output
NO
Note
In the first example Tenten first placed shurikens with prices 4 and 2. After this a customer came in and bought the cheapest shuriken which costed 2. Next, Tenten added a shuriken with price 3 on the showcase to the already placed 4-ryo. Then a new customer bought this 3-ryo shuriken. After this she added a 1-ryo shuriken. Finally, the last two customers bought shurikens 1 and 4, respectively. Note that the order [2, 4, 3, 1] is also valid.
In the second example the first customer bought a shuriken before anything was placed, which is clearly impossible.
In the third example Tenten put all her shurikens onto the showcase, after which a customer came in and bought a shuriken with price 2. This is impossible since the shuriken was not the cheapest, we know that the 1-ryo shuriken was also there. | instruction | 0 | 76,906 | 10 | 153,812 |
Tags: data structures, greedy, implementation
Correct Solution:
```
mod = 1000000007
eps = 10**-9
def main():
import sys
from heapq import heappush, heappop
input = sys.stdin.readline
N = int(input())
ev = []
for _ in range(2*N):
line = list(input().split())
ev.append(line)
ev.reverse()
pq = []
ans = []
for line in ev:
if len(line) == 1:
if not pq:
print("NO")
exit()
ans.append(heappop(pq))
else:
x = int(line[1])
if pq:
if x > pq[0]:
print("NO")
exit()
else:
heappush(pq, x)
else:
heappush(pq, x)
ans.reverse()
print("YES")
print(*ans)
if __name__ == '__main__':
main()
``` | output | 1 | 76,906 | 10 | 153,813 |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.