message
stringlengths 2
39.6k
| message_type
stringclasses 2
values | message_id
int64 0
1
| conversation_id
int64 450
109k
| cluster
float64 2
2
| __index_level_0__
int64 900
217k
|
|---|---|---|---|---|---|
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
Meka-Naruto plays a computer game. His character has the following ability: given an enemy hero, deal a instant damage to him, and then heal that enemy b health points at the end of every second, for exactly c seconds, starting one second after the ability is used. That means that if the ability is used at time t, the enemy's health decreases by a at time t, and then increases by b at time points t + 1, t + 2, ..., t + c due to this ability.
The ability has a cooldown of d seconds, i. e. if Meka-Naruto uses it at time moment t, next time he can use it is the time t + d. Please note that he can only use the ability at integer points in time, so all changes to the enemy's health also occur at integer times only.
The effects from different uses of the ability may stack with each other; that is, the enemy which is currently under k spells gets kβ
b amount of heal this time. Also, if several health changes occur at the same moment, they are all counted at once.
Now Meka-Naruto wonders if he can kill the enemy by just using the ability each time he can (that is, every d seconds). The enemy is killed if their health points become 0 or less. Assume that the enemy's health is not affected in any way other than by Meka-Naruto's character ability. What is the maximal number of health points the enemy can have so that Meka-Naruto is able to kill them?
Input
The first line contains an integer t (1β€ tβ€ 10^5) standing for the number of testcases.
Each test case is described with one line containing four numbers a, b, c and d (1β€ a, b, c, dβ€ 10^6) denoting the amount of instant damage, the amount of heal per second, the number of heals and the ability cooldown, respectively.
Output
For each testcase in a separate line print -1 if the skill can kill an enemy hero with an arbitrary number of health points, otherwise print the maximal number of health points of the enemy that can be killed.
Example
Input
7
1 1 1 1
2 2 2 2
1 2 3 4
4 3 2 1
228 21 11 3
239 21 11 3
1000000 1 1000000 1
Output
1
2
1
5
534
-1
500000500000
Note
In the first test case of the example each unit of damage is cancelled in a second, so Meka-Naruto cannot deal more than 1 damage.
In the fourth test case of the example the enemy gets:
* 4 damage (1-st spell cast) at time 0;
* 4 damage (2-nd spell cast) and 3 heal (1-st spell cast) at time 1 (the total of 5 damage to the initial health);
* 4 damage (3-nd spell cast) and 6 heal (1-st and 2-nd spell casts) at time 2 (the total of 3 damage to the initial health);
* and so on.
One can prove that there is no time where the enemy gets the total of 6 damage or more, so the answer is 5. Please note how the health is recalculated: for example, 8-health enemy would not die at time 1, as if we first subtracted 4 damage from his health and then considered him dead, before adding 3 heal.
In the sixth test case an arbitrarily healthy enemy can be killed in a sufficient amount of time.
In the seventh test case the answer does not fit into a 32-bit integer type.
Submitted Solution:
```
import sys,io,os;Z=io.BytesIO(os.read(0,os.fstat(0).st_size)).readline
o=[]
for _ in range(int(Z())):
a,b,c,d=map(int,Z().split())
if a>b*c:o+=[-1];continue
if d>c:o+=[a];continue
v=a//(b*d)
o+=[(v+1)*a-b*d*(v*(v+1))//2]
print('\n'.join(map(str,o)))
```
|
instruction
| 0
| 16,173
| 2
| 32,346
|
Yes
|
output
| 1
| 16,173
| 2
| 32,347
|
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
Meka-Naruto plays a computer game. His character has the following ability: given an enemy hero, deal a instant damage to him, and then heal that enemy b health points at the end of every second, for exactly c seconds, starting one second after the ability is used. That means that if the ability is used at time t, the enemy's health decreases by a at time t, and then increases by b at time points t + 1, t + 2, ..., t + c due to this ability.
The ability has a cooldown of d seconds, i. e. if Meka-Naruto uses it at time moment t, next time he can use it is the time t + d. Please note that he can only use the ability at integer points in time, so all changes to the enemy's health also occur at integer times only.
The effects from different uses of the ability may stack with each other; that is, the enemy which is currently under k spells gets kβ
b amount of heal this time. Also, if several health changes occur at the same moment, they are all counted at once.
Now Meka-Naruto wonders if he can kill the enemy by just using the ability each time he can (that is, every d seconds). The enemy is killed if their health points become 0 or less. Assume that the enemy's health is not affected in any way other than by Meka-Naruto's character ability. What is the maximal number of health points the enemy can have so that Meka-Naruto is able to kill them?
Input
The first line contains an integer t (1β€ tβ€ 10^5) standing for the number of testcases.
Each test case is described with one line containing four numbers a, b, c and d (1β€ a, b, c, dβ€ 10^6) denoting the amount of instant damage, the amount of heal per second, the number of heals and the ability cooldown, respectively.
Output
For each testcase in a separate line print -1 if the skill can kill an enemy hero with an arbitrary number of health points, otherwise print the maximal number of health points of the enemy that can be killed.
Example
Input
7
1 1 1 1
2 2 2 2
1 2 3 4
4 3 2 1
228 21 11 3
239 21 11 3
1000000 1 1000000 1
Output
1
2
1
5
534
-1
500000500000
Note
In the first test case of the example each unit of damage is cancelled in a second, so Meka-Naruto cannot deal more than 1 damage.
In the fourth test case of the example the enemy gets:
* 4 damage (1-st spell cast) at time 0;
* 4 damage (2-nd spell cast) and 3 heal (1-st spell cast) at time 1 (the total of 5 damage to the initial health);
* 4 damage (3-nd spell cast) and 6 heal (1-st and 2-nd spell casts) at time 2 (the total of 3 damage to the initial health);
* and so on.
One can prove that there is no time where the enemy gets the total of 6 damage or more, so the answer is 5. Please note how the health is recalculated: for example, 8-health enemy would not die at time 1, as if we first subtracted 4 damage from his health and then considered him dead, before adding 3 heal.
In the sixth test case an arbitrarily healthy enemy can be killed in a sufficient amount of time.
In the seventh test case the answer does not fit into a 32-bit integer type.
Submitted Solution:
```
from sys import stdin
t = int(input())
for i_t in range(t):
a, b, c, d = map(int, stdin.readline().split())
if b*c < a:
result = -1
else:
i_hit = (a + b*d - 1) // (b*d)
i_hit = min(i_hit, c // d)
result = a * (i_hit+1) - b*d * i_hit*(i_hit+1)//2
print(result)
```
|
instruction
| 0
| 16,174
| 2
| 32,348
|
No
|
output
| 1
| 16,174
| 2
| 32,349
|
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
Meka-Naruto plays a computer game. His character has the following ability: given an enemy hero, deal a instant damage to him, and then heal that enemy b health points at the end of every second, for exactly c seconds, starting one second after the ability is used. That means that if the ability is used at time t, the enemy's health decreases by a at time t, and then increases by b at time points t + 1, t + 2, ..., t + c due to this ability.
The ability has a cooldown of d seconds, i. e. if Meka-Naruto uses it at time moment t, next time he can use it is the time t + d. Please note that he can only use the ability at integer points in time, so all changes to the enemy's health also occur at integer times only.
The effects from different uses of the ability may stack with each other; that is, the enemy which is currently under k spells gets kβ
b amount of heal this time. Also, if several health changes occur at the same moment, they are all counted at once.
Now Meka-Naruto wonders if he can kill the enemy by just using the ability each time he can (that is, every d seconds). The enemy is killed if their health points become 0 or less. Assume that the enemy's health is not affected in any way other than by Meka-Naruto's character ability. What is the maximal number of health points the enemy can have so that Meka-Naruto is able to kill them?
Input
The first line contains an integer t (1β€ tβ€ 10^5) standing for the number of testcases.
Each test case is described with one line containing four numbers a, b, c and d (1β€ a, b, c, dβ€ 10^6) denoting the amount of instant damage, the amount of heal per second, the number of heals and the ability cooldown, respectively.
Output
For each testcase in a separate line print -1 if the skill can kill an enemy hero with an arbitrary number of health points, otherwise print the maximal number of health points of the enemy that can be killed.
Example
Input
7
1 1 1 1
2 2 2 2
1 2 3 4
4 3 2 1
228 21 11 3
239 21 11 3
1000000 1 1000000 1
Output
1
2
1
5
534
-1
500000500000
Note
In the first test case of the example each unit of damage is cancelled in a second, so Meka-Naruto cannot deal more than 1 damage.
In the fourth test case of the example the enemy gets:
* 4 damage (1-st spell cast) at time 0;
* 4 damage (2-nd spell cast) and 3 heal (1-st spell cast) at time 1 (the total of 5 damage to the initial health);
* 4 damage (3-nd spell cast) and 6 heal (1-st and 2-nd spell casts) at time 2 (the total of 3 damage to the initial health);
* and so on.
One can prove that there is no time where the enemy gets the total of 6 damage or more, so the answer is 5. Please note how the health is recalculated: for example, 8-health enemy would not die at time 1, as if we first subtracted 4 damage from his health and then considered him dead, before adding 3 heal.
In the sixth test case an arbitrarily healthy enemy can be killed in a sufficient amount of time.
In the seventh test case the answer does not fit into a 32-bit integer type.
Submitted Solution:
```
for _ in range(int(input())):
a,b,c,d=map(int,input().split())
print((((a-1)/b)/d+1)*a-((a-1)/b/d)*((a-1)/b/d+1)/2*b*d)
```
|
instruction
| 0
| 16,175
| 2
| 32,350
|
No
|
output
| 1
| 16,175
| 2
| 32,351
|
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
Meka-Naruto plays a computer game. His character has the following ability: given an enemy hero, deal a instant damage to him, and then heal that enemy b health points at the end of every second, for exactly c seconds, starting one second after the ability is used. That means that if the ability is used at time t, the enemy's health decreases by a at time t, and then increases by b at time points t + 1, t + 2, ..., t + c due to this ability.
The ability has a cooldown of d seconds, i. e. if Meka-Naruto uses it at time moment t, next time he can use it is the time t + d. Please note that he can only use the ability at integer points in time, so all changes to the enemy's health also occur at integer times only.
The effects from different uses of the ability may stack with each other; that is, the enemy which is currently under k spells gets kβ
b amount of heal this time. Also, if several health changes occur at the same moment, they are all counted at once.
Now Meka-Naruto wonders if he can kill the enemy by just using the ability each time he can (that is, every d seconds). The enemy is killed if their health points become 0 or less. Assume that the enemy's health is not affected in any way other than by Meka-Naruto's character ability. What is the maximal number of health points the enemy can have so that Meka-Naruto is able to kill them?
Input
The first line contains an integer t (1β€ tβ€ 10^5) standing for the number of testcases.
Each test case is described with one line containing four numbers a, b, c and d (1β€ a, b, c, dβ€ 10^6) denoting the amount of instant damage, the amount of heal per second, the number of heals and the ability cooldown, respectively.
Output
For each testcase in a separate line print -1 if the skill can kill an enemy hero with an arbitrary number of health points, otherwise print the maximal number of health points of the enemy that can be killed.
Example
Input
7
1 1 1 1
2 2 2 2
1 2 3 4
4 3 2 1
228 21 11 3
239 21 11 3
1000000 1 1000000 1
Output
1
2
1
5
534
-1
500000500000
Note
In the first test case of the example each unit of damage is cancelled in a second, so Meka-Naruto cannot deal more than 1 damage.
In the fourth test case of the example the enemy gets:
* 4 damage (1-st spell cast) at time 0;
* 4 damage (2-nd spell cast) and 3 heal (1-st spell cast) at time 1 (the total of 5 damage to the initial health);
* 4 damage (3-nd spell cast) and 6 heal (1-st and 2-nd spell casts) at time 2 (the total of 3 damage to the initial health);
* and so on.
One can prove that there is no time where the enemy gets the total of 6 damage or more, so the answer is 5. Please note how the health is recalculated: for example, 8-health enemy would not die at time 1, as if we first subtracted 4 damage from his health and then considered him dead, before adding 3 heal.
In the sixth test case an arbitrarily healthy enemy can be killed in a sufficient amount of time.
In the seventh test case the answer does not fit into a 32-bit integer type.
Submitted Solution:
```
def print_hi(name):
n=int(input())
min=11111111111111111
j=0
n=0
m=0
for i in range(n+1):
a, b,c,d = map(int,input().split(' '))
c1=0
if a/d<=b*c:
while j<=10000000:
if c1==c+1:
c1=0
k=-b*c1
m-=k
if min<=m:
print(abs(int(min)))
j=10000000
min = m
c1+=1
j+=1
else:
print(1)
if __name__ == '__main__':
print_hi('PyCharm')
```
|
instruction
| 0
| 16,176
| 2
| 32,352
|
No
|
output
| 1
| 16,176
| 2
| 32,353
|
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
Meka-Naruto plays a computer game. His character has the following ability: given an enemy hero, deal a instant damage to him, and then heal that enemy b health points at the end of every second, for exactly c seconds, starting one second after the ability is used. That means that if the ability is used at time t, the enemy's health decreases by a at time t, and then increases by b at time points t + 1, t + 2, ..., t + c due to this ability.
The ability has a cooldown of d seconds, i. e. if Meka-Naruto uses it at time moment t, next time he can use it is the time t + d. Please note that he can only use the ability at integer points in time, so all changes to the enemy's health also occur at integer times only.
The effects from different uses of the ability may stack with each other; that is, the enemy which is currently under k spells gets kβ
b amount of heal this time. Also, if several health changes occur at the same moment, they are all counted at once.
Now Meka-Naruto wonders if he can kill the enemy by just using the ability each time he can (that is, every d seconds). The enemy is killed if their health points become 0 or less. Assume that the enemy's health is not affected in any way other than by Meka-Naruto's character ability. What is the maximal number of health points the enemy can have so that Meka-Naruto is able to kill them?
Input
The first line contains an integer t (1β€ tβ€ 10^5) standing for the number of testcases.
Each test case is described with one line containing four numbers a, b, c and d (1β€ a, b, c, dβ€ 10^6) denoting the amount of instant damage, the amount of heal per second, the number of heals and the ability cooldown, respectively.
Output
For each testcase in a separate line print -1 if the skill can kill an enemy hero with an arbitrary number of health points, otherwise print the maximal number of health points of the enemy that can be killed.
Example
Input
7
1 1 1 1
2 2 2 2
1 2 3 4
4 3 2 1
228 21 11 3
239 21 11 3
1000000 1 1000000 1
Output
1
2
1
5
534
-1
500000500000
Note
In the first test case of the example each unit of damage is cancelled in a second, so Meka-Naruto cannot deal more than 1 damage.
In the fourth test case of the example the enemy gets:
* 4 damage (1-st spell cast) at time 0;
* 4 damage (2-nd spell cast) and 3 heal (1-st spell cast) at time 1 (the total of 5 damage to the initial health);
* 4 damage (3-nd spell cast) and 6 heal (1-st and 2-nd spell casts) at time 2 (the total of 3 damage to the initial health);
* and so on.
One can prove that there is no time where the enemy gets the total of 6 damage or more, so the answer is 5. Please note how the health is recalculated: for example, 8-health enemy would not die at time 1, as if we first subtracted 4 damage from his health and then considered him dead, before adding 3 heal.
In the sixth test case an arbitrarily healthy enemy can be killed in a sufficient amount of time.
In the seventh test case the answer does not fit into a 32-bit integer type.
Submitted Solution:
```
import math
t = int(input())
for i in range(t):
a, b, c, d = map(float,input().split())
badm = int(math.ceil(a / b))
if badm > c:
print(-1)
else:
goodm = (badm - 1)
#goodm -= goodm % d
times = goodm // d
dmg = ((times + 1) * a) - (times * (times + 1) // 2 * d * b)
print(dmg)
```
|
instruction
| 0
| 16,177
| 2
| 32,354
|
No
|
output
| 1
| 16,177
| 2
| 32,355
|
Provide tags and a correct Python 3 solution for this coding contest problem.
You play your favourite game yet another time. You chose the character you didn't play before. It has str points of strength and int points of intelligence. Also, at start, the character has exp free experience points you can invest either in strength or in intelligence (by investing one point you can either raise strength by 1 or raise intelligence by 1).
Since you'd like to make some fun you want to create a jock character, so it has more strength than intelligence points (resulting strength is strictly greater than the resulting intelligence).
Calculate the number of different character builds you can create (for the purpose of replayability) if you must invest all free points. Two character builds are different if their strength and/or intellect are different.
Input
The first line contains the single integer T (1 β€ T β€ 100) β the number of queries. Next T lines contain descriptions of queries β one per line.
This line contains three integers str, int and exp (1 β€ str, int β€ 10^8, 0 β€ exp β€ 10^8) β the initial strength and intelligence of the character and the number of free points, respectively.
Output
Print T integers β one per query. For each query print the number of different character builds you can create.
Example
Input
4
5 3 4
2 1 0
3 5 5
4 10 6
Output
3
1
2
0
Note
In the first query there are only three appropriate character builds: (str = 7, int = 5), (8, 4) and (9, 3). All other builds are either too smart or don't use all free points.
In the second query there is only one possible build: (2, 1).
In the third query there are two appropriate builds: (7, 6), (8, 5).
In the fourth query all builds have too much brains.
|
instruction
| 0
| 16,927
| 2
| 33,854
|
Tags: binary search, math
Correct Solution:
```
for _ in range(int(input())):
s, i, e = list(map(int, input().strip().split()))
if s + e <= i:
ans = 0
else:
if e == 0:
ans = 1
else:
## calculating upper and lower bounds for given s,i using e
au, bu = s+e, i
ad, bd = s, i+e
if ad > bd:
ans = au - ad + 1
elif ad == bd:
ans = au - ad
else:
ans = au - ad - (bd-ad)//2
print(ans)
```
|
output
| 1
| 16,927
| 2
| 33,855
|
Provide tags and a correct Python 3 solution for this coding contest problem.
You play your favourite game yet another time. You chose the character you didn't play before. It has str points of strength and int points of intelligence. Also, at start, the character has exp free experience points you can invest either in strength or in intelligence (by investing one point you can either raise strength by 1 or raise intelligence by 1).
Since you'd like to make some fun you want to create a jock character, so it has more strength than intelligence points (resulting strength is strictly greater than the resulting intelligence).
Calculate the number of different character builds you can create (for the purpose of replayability) if you must invest all free points. Two character builds are different if their strength and/or intellect are different.
Input
The first line contains the single integer T (1 β€ T β€ 100) β the number of queries. Next T lines contain descriptions of queries β one per line.
This line contains three integers str, int and exp (1 β€ str, int β€ 10^8, 0 β€ exp β€ 10^8) β the initial strength and intelligence of the character and the number of free points, respectively.
Output
Print T integers β one per query. For each query print the number of different character builds you can create.
Example
Input
4
5 3 4
2 1 0
3 5 5
4 10 6
Output
3
1
2
0
Note
In the first query there are only three appropriate character builds: (str = 7, int = 5), (8, 4) and (9, 3). All other builds are either too smart or don't use all free points.
In the second query there is only one possible build: (2, 1).
In the third query there are two appropriate builds: (7, 6), (8, 5).
In the fourth query all builds have too much brains.
|
instruction
| 0
| 16,928
| 2
| 33,856
|
Tags: binary search, math
Correct Solution:
```
for i in range(int(input())):
s,i,e=map(int,input().split())
print(max(0,min((s-i+e+1)>>1,e+1)))
```
|
output
| 1
| 16,928
| 2
| 33,857
|
Provide tags and a correct Python 3 solution for this coding contest problem.
You play your favourite game yet another time. You chose the character you didn't play before. It has str points of strength and int points of intelligence. Also, at start, the character has exp free experience points you can invest either in strength or in intelligence (by investing one point you can either raise strength by 1 or raise intelligence by 1).
Since you'd like to make some fun you want to create a jock character, so it has more strength than intelligence points (resulting strength is strictly greater than the resulting intelligence).
Calculate the number of different character builds you can create (for the purpose of replayability) if you must invest all free points. Two character builds are different if their strength and/or intellect are different.
Input
The first line contains the single integer T (1 β€ T β€ 100) β the number of queries. Next T lines contain descriptions of queries β one per line.
This line contains three integers str, int and exp (1 β€ str, int β€ 10^8, 0 β€ exp β€ 10^8) β the initial strength and intelligence of the character and the number of free points, respectively.
Output
Print T integers β one per query. For each query print the number of different character builds you can create.
Example
Input
4
5 3 4
2 1 0
3 5 5
4 10 6
Output
3
1
2
0
Note
In the first query there are only three appropriate character builds: (str = 7, int = 5), (8, 4) and (9, 3). All other builds are either too smart or don't use all free points.
In the second query there is only one possible build: (2, 1).
In the third query there are two appropriate builds: (7, 6), (8, 5).
In the fourth query all builds have too much brains.
|
instruction
| 0
| 16,929
| 2
| 33,858
|
Tags: binary search, math
Correct Solution:
```
def main():
T = int(input())
for i in range(T):
a, b, c = input().split()
a, b, c = int(a), int(b), int(c)
ans = (a + c - b + 1) // 2
ans = max(ans, 0)
ans = min(ans, c+1)
print(ans)
if __name__ == '__main__':
main()
```
|
output
| 1
| 16,929
| 2
| 33,859
|
Provide tags and a correct Python 3 solution for this coding contest problem.
You play your favourite game yet another time. You chose the character you didn't play before. It has str points of strength and int points of intelligence. Also, at start, the character has exp free experience points you can invest either in strength or in intelligence (by investing one point you can either raise strength by 1 or raise intelligence by 1).
Since you'd like to make some fun you want to create a jock character, so it has more strength than intelligence points (resulting strength is strictly greater than the resulting intelligence).
Calculate the number of different character builds you can create (for the purpose of replayability) if you must invest all free points. Two character builds are different if their strength and/or intellect are different.
Input
The first line contains the single integer T (1 β€ T β€ 100) β the number of queries. Next T lines contain descriptions of queries β one per line.
This line contains three integers str, int and exp (1 β€ str, int β€ 10^8, 0 β€ exp β€ 10^8) β the initial strength and intelligence of the character and the number of free points, respectively.
Output
Print T integers β one per query. For each query print the number of different character builds you can create.
Example
Input
4
5 3 4
2 1 0
3 5 5
4 10 6
Output
3
1
2
0
Note
In the first query there are only three appropriate character builds: (str = 7, int = 5), (8, 4) and (9, 3). All other builds are either too smart or don't use all free points.
In the second query there is only one possible build: (2, 1).
In the third query there are two appropriate builds: (7, 6), (8, 5).
In the fourth query all builds have too much brains.
|
instruction
| 0
| 16,930
| 2
| 33,860
|
Tags: binary search, math
Correct Solution:
```
t = int(input())
for _ in range(t):
q = list(map(int, input().split()))
x = max(0, int((q[1] + q[2] - q[0] + 2) / 2))
print(max(0, (q[2] - x + 1)))
```
|
output
| 1
| 16,930
| 2
| 33,861
|
Provide tags and a correct Python 3 solution for this coding contest problem.
You play your favourite game yet another time. You chose the character you didn't play before. It has str points of strength and int points of intelligence. Also, at start, the character has exp free experience points you can invest either in strength or in intelligence (by investing one point you can either raise strength by 1 or raise intelligence by 1).
Since you'd like to make some fun you want to create a jock character, so it has more strength than intelligence points (resulting strength is strictly greater than the resulting intelligence).
Calculate the number of different character builds you can create (for the purpose of replayability) if you must invest all free points. Two character builds are different if their strength and/or intellect are different.
Input
The first line contains the single integer T (1 β€ T β€ 100) β the number of queries. Next T lines contain descriptions of queries β one per line.
This line contains three integers str, int and exp (1 β€ str, int β€ 10^8, 0 β€ exp β€ 10^8) β the initial strength and intelligence of the character and the number of free points, respectively.
Output
Print T integers β one per query. For each query print the number of different character builds you can create.
Example
Input
4
5 3 4
2 1 0
3 5 5
4 10 6
Output
3
1
2
0
Note
In the first query there are only three appropriate character builds: (str = 7, int = 5), (8, 4) and (9, 3). All other builds are either too smart or don't use all free points.
In the second query there is only one possible build: (2, 1).
In the third query there are two appropriate builds: (7, 6), (8, 5).
In the fourth query all builds have too much brains.
|
instruction
| 0
| 16,931
| 2
| 33,862
|
Tags: binary search, math
Correct Solution:
```
import math
for t in range(int(input())):
n,m,k=map(int,input().split())
x=n+k
x=x-m
if(x<=0):
print(0)
elif((k+m)<n):
print(k+1)
elif((k+m)==n):
print(k)
else:
print(math.ceil(x/2))
```
|
output
| 1
| 16,931
| 2
| 33,863
|
Provide tags and a correct Python 3 solution for this coding contest problem.
You play your favourite game yet another time. You chose the character you didn't play before. It has str points of strength and int points of intelligence. Also, at start, the character has exp free experience points you can invest either in strength or in intelligence (by investing one point you can either raise strength by 1 or raise intelligence by 1).
Since you'd like to make some fun you want to create a jock character, so it has more strength than intelligence points (resulting strength is strictly greater than the resulting intelligence).
Calculate the number of different character builds you can create (for the purpose of replayability) if you must invest all free points. Two character builds are different if their strength and/or intellect are different.
Input
The first line contains the single integer T (1 β€ T β€ 100) β the number of queries. Next T lines contain descriptions of queries β one per line.
This line contains three integers str, int and exp (1 β€ str, int β€ 10^8, 0 β€ exp β€ 10^8) β the initial strength and intelligence of the character and the number of free points, respectively.
Output
Print T integers β one per query. For each query print the number of different character builds you can create.
Example
Input
4
5 3 4
2 1 0
3 5 5
4 10 6
Output
3
1
2
0
Note
In the first query there are only three appropriate character builds: (str = 7, int = 5), (8, 4) and (9, 3). All other builds are either too smart or don't use all free points.
In the second query there is only one possible build: (2, 1).
In the third query there are two appropriate builds: (7, 6), (8, 5).
In the fourth query all builds have too much brains.
|
instruction
| 0
| 16,932
| 2
| 33,864
|
Tags: binary search, math
Correct Solution:
```
t = int(input())
for i in range(t):
a, b, c = map(int, input().split())
l = 0
r = c + 1
while l < r:
m = (r + l) // 2
if a + m > b + c - m:
r = m
else:
l = m + 1
if (l > c):
print(0)
else:
print(c - l + 1)
```
|
output
| 1
| 16,932
| 2
| 33,865
|
Provide tags and a correct Python 3 solution for this coding contest problem.
You play your favourite game yet another time. You chose the character you didn't play before. It has str points of strength and int points of intelligence. Also, at start, the character has exp free experience points you can invest either in strength or in intelligence (by investing one point you can either raise strength by 1 or raise intelligence by 1).
Since you'd like to make some fun you want to create a jock character, so it has more strength than intelligence points (resulting strength is strictly greater than the resulting intelligence).
Calculate the number of different character builds you can create (for the purpose of replayability) if you must invest all free points. Two character builds are different if their strength and/or intellect are different.
Input
The first line contains the single integer T (1 β€ T β€ 100) β the number of queries. Next T lines contain descriptions of queries β one per line.
This line contains three integers str, int and exp (1 β€ str, int β€ 10^8, 0 β€ exp β€ 10^8) β the initial strength and intelligence of the character and the number of free points, respectively.
Output
Print T integers β one per query. For each query print the number of different character builds you can create.
Example
Input
4
5 3 4
2 1 0
3 5 5
4 10 6
Output
3
1
2
0
Note
In the first query there are only three appropriate character builds: (str = 7, int = 5), (8, 4) and (9, 3). All other builds are either too smart or don't use all free points.
In the second query there is only one possible build: (2, 1).
In the third query there are two appropriate builds: (7, 6), (8, 5).
In the fourth query all builds have too much brains.
|
instruction
| 0
| 16,933
| 2
| 33,866
|
Tags: binary search, math
Correct Solution:
```
s = input() #cantidad de datos a ingresar
s = int(s)
A = [] # entradas
S = [] # salidas
for i in range(s):
o = input()
o = o.split(' ')
(a,b,c) = (int(o[0]),int(o[1]), int(o[2]))
A.append((a,b,c))
for i in A:
s = i[0]+i[2]
if s <= i[1]:
S.append(0)
else:
car = int((s-i[1]+1)/2)
m = min(car, i[2]+1)
S.append(m)
for i in S:
print(i)
```
|
output
| 1
| 16,933
| 2
| 33,867
|
Provide tags and a correct Python 3 solution for this coding contest problem.
You play your favourite game yet another time. You chose the character you didn't play before. It has str points of strength and int points of intelligence. Also, at start, the character has exp free experience points you can invest either in strength or in intelligence (by investing one point you can either raise strength by 1 or raise intelligence by 1).
Since you'd like to make some fun you want to create a jock character, so it has more strength than intelligence points (resulting strength is strictly greater than the resulting intelligence).
Calculate the number of different character builds you can create (for the purpose of replayability) if you must invest all free points. Two character builds are different if their strength and/or intellect are different.
Input
The first line contains the single integer T (1 β€ T β€ 100) β the number of queries. Next T lines contain descriptions of queries β one per line.
This line contains three integers str, int and exp (1 β€ str, int β€ 10^8, 0 β€ exp β€ 10^8) β the initial strength and intelligence of the character and the number of free points, respectively.
Output
Print T integers β one per query. For each query print the number of different character builds you can create.
Example
Input
4
5 3 4
2 1 0
3 5 5
4 10 6
Output
3
1
2
0
Note
In the first query there are only three appropriate character builds: (str = 7, int = 5), (8, 4) and (9, 3). All other builds are either too smart or don't use all free points.
In the second query there is only one possible build: (2, 1).
In the third query there are two appropriate builds: (7, 6), (8, 5).
In the fourth query all builds have too much brains.
|
instruction
| 0
| 16,934
| 2
| 33,868
|
Tags: binary search, math
Correct Solution:
```
def char(s,i,exp):
dif = s-i
r=exp
l=0
ans = None
while r>=l:
m = l+(r-l)//2
mreal = exp*-1+m*2
if mreal+dif>0:
r=m-1
ans = m
else: l = m+1
if ans==None:
if dif>0:
return 1
return 0
return exp+1-ans
T = int(input())
for _ in range(T):
s,i,exp = map(int,input().split())
print(char(s,i,exp))
```
|
output
| 1
| 16,934
| 2
| 33,869
|
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
You play your favourite game yet another time. You chose the character you didn't play before. It has str points of strength and int points of intelligence. Also, at start, the character has exp free experience points you can invest either in strength or in intelligence (by investing one point you can either raise strength by 1 or raise intelligence by 1).
Since you'd like to make some fun you want to create a jock character, so it has more strength than intelligence points (resulting strength is strictly greater than the resulting intelligence).
Calculate the number of different character builds you can create (for the purpose of replayability) if you must invest all free points. Two character builds are different if their strength and/or intellect are different.
Input
The first line contains the single integer T (1 β€ T β€ 100) β the number of queries. Next T lines contain descriptions of queries β one per line.
This line contains three integers str, int and exp (1 β€ str, int β€ 10^8, 0 β€ exp β€ 10^8) β the initial strength and intelligence of the character and the number of free points, respectively.
Output
Print T integers β one per query. For each query print the number of different character builds you can create.
Example
Input
4
5 3 4
2 1 0
3 5 5
4 10 6
Output
3
1
2
0
Note
In the first query there are only three appropriate character builds: (str = 7, int = 5), (8, 4) and (9, 3). All other builds are either too smart or don't use all free points.
In the second query there is only one possible build: (2, 1).
In the third query there are two appropriate builds: (7, 6), (8, 5).
In the fourth query all builds have too much brains.
Submitted Solution:
```
# Contest: Educational Codeforces Round 72 (Rated for Div. 2) (https://codeforces.com/contest/1217)
# Problem: A: Creating a Character (https://codeforces.com/contest/1217/problem/A)
def rint():
return int(input())
def rints():
return list(map(int, input().split()))
t = rint()
for _ in range(t):
s, i, e = rints()
if e == 0:
print(1 if s > i else 0)
continue
e -= max(0, i - s + 1)
s = max(s, i + 1)
if e < 0:
print(0)
continue
to_int = min(s - 1 - i, e)
to_int += (e - to_int) // 2
print(to_int + 1)
```
|
instruction
| 0
| 16,935
| 2
| 33,870
|
Yes
|
output
| 1
| 16,935
| 2
| 33,871
|
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
You play your favourite game yet another time. You chose the character you didn't play before. It has str points of strength and int points of intelligence. Also, at start, the character has exp free experience points you can invest either in strength or in intelligence (by investing one point you can either raise strength by 1 or raise intelligence by 1).
Since you'd like to make some fun you want to create a jock character, so it has more strength than intelligence points (resulting strength is strictly greater than the resulting intelligence).
Calculate the number of different character builds you can create (for the purpose of replayability) if you must invest all free points. Two character builds are different if their strength and/or intellect are different.
Input
The first line contains the single integer T (1 β€ T β€ 100) β the number of queries. Next T lines contain descriptions of queries β one per line.
This line contains three integers str, int and exp (1 β€ str, int β€ 10^8, 0 β€ exp β€ 10^8) β the initial strength and intelligence of the character and the number of free points, respectively.
Output
Print T integers β one per query. For each query print the number of different character builds you can create.
Example
Input
4
5 3 4
2 1 0
3 5 5
4 10 6
Output
3
1
2
0
Note
In the first query there are only three appropriate character builds: (str = 7, int = 5), (8, 4) and (9, 3). All other builds are either too smart or don't use all free points.
In the second query there is only one possible build: (2, 1).
In the third query there are two appropriate builds: (7, 6), (8, 5).
In the fourth query all builds have too much brains.
Submitted Solution:
```
for _ in range(int(input())):
s,i,e=map(int,input().split())
if e==0:
if s>i:print(1)
else:print(0)
else:
x=s+e
if x>i:print(min(e+1,(x-i)//2+(x-i)%2))
else:print(0)
```
|
instruction
| 0
| 16,936
| 2
| 33,872
|
Yes
|
output
| 1
| 16,936
| 2
| 33,873
|
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
You play your favourite game yet another time. You chose the character you didn't play before. It has str points of strength and int points of intelligence. Also, at start, the character has exp free experience points you can invest either in strength or in intelligence (by investing one point you can either raise strength by 1 or raise intelligence by 1).
Since you'd like to make some fun you want to create a jock character, so it has more strength than intelligence points (resulting strength is strictly greater than the resulting intelligence).
Calculate the number of different character builds you can create (for the purpose of replayability) if you must invest all free points. Two character builds are different if their strength and/or intellect are different.
Input
The first line contains the single integer T (1 β€ T β€ 100) β the number of queries. Next T lines contain descriptions of queries β one per line.
This line contains three integers str, int and exp (1 β€ str, int β€ 10^8, 0 β€ exp β€ 10^8) β the initial strength and intelligence of the character and the number of free points, respectively.
Output
Print T integers β one per query. For each query print the number of different character builds you can create.
Example
Input
4
5 3 4
2 1 0
3 5 5
4 10 6
Output
3
1
2
0
Note
In the first query there are only three appropriate character builds: (str = 7, int = 5), (8, 4) and (9, 3). All other builds are either too smart or don't use all free points.
In the second query there is only one possible build: (2, 1).
In the third query there are two appropriate builds: (7, 6), (8, 5).
In the fourth query all builds have too much brains.
Submitted Solution:
```
N=int(input())
for i in range(N):
s,n,e=list(map(int,input().split()))
if e==0:
if s>n:
print(1)
else:
print(0)
continue
s+=e;
if s-n>0 and s-n<=2*e:
print((s-n)//2+((s-n)%2))
elif s-n>2*e:
print(e+1)
else:
print(0)
```
|
instruction
| 0
| 16,937
| 2
| 33,874
|
Yes
|
output
| 1
| 16,937
| 2
| 33,875
|
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
You play your favourite game yet another time. You chose the character you didn't play before. It has str points of strength and int points of intelligence. Also, at start, the character has exp free experience points you can invest either in strength or in intelligence (by investing one point you can either raise strength by 1 or raise intelligence by 1).
Since you'd like to make some fun you want to create a jock character, so it has more strength than intelligence points (resulting strength is strictly greater than the resulting intelligence).
Calculate the number of different character builds you can create (for the purpose of replayability) if you must invest all free points. Two character builds are different if their strength and/or intellect are different.
Input
The first line contains the single integer T (1 β€ T β€ 100) β the number of queries. Next T lines contain descriptions of queries β one per line.
This line contains three integers str, int and exp (1 β€ str, int β€ 10^8, 0 β€ exp β€ 10^8) β the initial strength and intelligence of the character and the number of free points, respectively.
Output
Print T integers β one per query. For each query print the number of different character builds you can create.
Example
Input
4
5 3 4
2 1 0
3 5 5
4 10 6
Output
3
1
2
0
Note
In the first query there are only three appropriate character builds: (str = 7, int = 5), (8, 4) and (9, 3). All other builds are either too smart or don't use all free points.
In the second query there is only one possible build: (2, 1).
In the third query there are two appropriate builds: (7, 6), (8, 5).
In the fourth query all builds have too much brains.
Submitted Solution:
```
def mm(x,y,z):
s=x+y+z
if s%2==0:
return s//2+1
else:
return (s+1)//2
def ans(x,y,z):
m=mm(x,y,z)
if (x+z<m): return 0
elif x<=m: return x+z-m+1
else: return z+1
t=int(input())
for i in range(t):
a,b,c=map(int,input().split())
print(ans(a,b,c))
```
|
instruction
| 0
| 16,938
| 2
| 33,876
|
Yes
|
output
| 1
| 16,938
| 2
| 33,877
|
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
You play your favourite game yet another time. You chose the character you didn't play before. It has str points of strength and int points of intelligence. Also, at start, the character has exp free experience points you can invest either in strength or in intelligence (by investing one point you can either raise strength by 1 or raise intelligence by 1).
Since you'd like to make some fun you want to create a jock character, so it has more strength than intelligence points (resulting strength is strictly greater than the resulting intelligence).
Calculate the number of different character builds you can create (for the purpose of replayability) if you must invest all free points. Two character builds are different if their strength and/or intellect are different.
Input
The first line contains the single integer T (1 β€ T β€ 100) β the number of queries. Next T lines contain descriptions of queries β one per line.
This line contains three integers str, int and exp (1 β€ str, int β€ 10^8, 0 β€ exp β€ 10^8) β the initial strength and intelligence of the character and the number of free points, respectively.
Output
Print T integers β one per query. For each query print the number of different character builds you can create.
Example
Input
4
5 3 4
2 1 0
3 5 5
4 10 6
Output
3
1
2
0
Note
In the first query there are only three appropriate character builds: (str = 7, int = 5), (8, 4) and (9, 3). All other builds are either too smart or don't use all free points.
In the second query there is only one possible build: (2, 1).
In the third query there are two appropriate builds: (7, 6), (8, 5).
In the fourth query all builds have too much brains.
Submitted Solution:
```
n = int(input())
ans=[]
for i in range (n):
s,i,e = map(int,input().split())
if i-s>=e:
k=0
ans.append(k)
elif e == 0:
ans.append(1)
elif s>=i:
k=1
s+=e
k+=(s-i)//2
if (s-i)%2==0:
k-=1
ans.append(k)
elif i>s:
k=1
s+=e
k+=(s-i)//2
if (s-i)%2==0:
k-=1
ans.append(k)
for i in ans:
print(i)
```
|
instruction
| 0
| 16,939
| 2
| 33,878
|
No
|
output
| 1
| 16,939
| 2
| 33,879
|
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
You play your favourite game yet another time. You chose the character you didn't play before. It has str points of strength and int points of intelligence. Also, at start, the character has exp free experience points you can invest either in strength or in intelligence (by investing one point you can either raise strength by 1 or raise intelligence by 1).
Since you'd like to make some fun you want to create a jock character, so it has more strength than intelligence points (resulting strength is strictly greater than the resulting intelligence).
Calculate the number of different character builds you can create (for the purpose of replayability) if you must invest all free points. Two character builds are different if their strength and/or intellect are different.
Input
The first line contains the single integer T (1 β€ T β€ 100) β the number of queries. Next T lines contain descriptions of queries β one per line.
This line contains three integers str, int and exp (1 β€ str, int β€ 10^8, 0 β€ exp β€ 10^8) β the initial strength and intelligence of the character and the number of free points, respectively.
Output
Print T integers β one per query. For each query print the number of different character builds you can create.
Example
Input
4
5 3 4
2 1 0
3 5 5
4 10 6
Output
3
1
2
0
Note
In the first query there are only three appropriate character builds: (str = 7, int = 5), (8, 4) and (9, 3). All other builds are either too smart or don't use all free points.
In the second query there is only one possible build: (2, 1).
In the third query there are two appropriate builds: (7, 6), (8, 5).
In the fourth query all builds have too much brains.
Submitted Solution:
```
t = int(input())
for _ in range(t):
s,i,e = list(map(int,input().split()))
k = (s+e)-((s+i+e)//2)
if k<=0:
print(0)
else:
print(k)
```
|
instruction
| 0
| 16,940
| 2
| 33,880
|
No
|
output
| 1
| 16,940
| 2
| 33,881
|
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
You play your favourite game yet another time. You chose the character you didn't play before. It has str points of strength and int points of intelligence. Also, at start, the character has exp free experience points you can invest either in strength or in intelligence (by investing one point you can either raise strength by 1 or raise intelligence by 1).
Since you'd like to make some fun you want to create a jock character, so it has more strength than intelligence points (resulting strength is strictly greater than the resulting intelligence).
Calculate the number of different character builds you can create (for the purpose of replayability) if you must invest all free points. Two character builds are different if their strength and/or intellect are different.
Input
The first line contains the single integer T (1 β€ T β€ 100) β the number of queries. Next T lines contain descriptions of queries β one per line.
This line contains three integers str, int and exp (1 β€ str, int β€ 10^8, 0 β€ exp β€ 10^8) β the initial strength and intelligence of the character and the number of free points, respectively.
Output
Print T integers β one per query. For each query print the number of different character builds you can create.
Example
Input
4
5 3 4
2 1 0
3 5 5
4 10 6
Output
3
1
2
0
Note
In the first query there are only three appropriate character builds: (str = 7, int = 5), (8, 4) and (9, 3). All other builds are either too smart or don't use all free points.
In the second query there is only one possible build: (2, 1).
In the third query there are two appropriate builds: (7, 6), (8, 5).
In the fourth query all builds have too much brains.
Submitted Solution:
```
# cook your dish here
t=int(input())
for _ in range(t):
s,i,e=map(int,input().split(" "))
if s>i:
if s-i>e:
print(e+1)
else:
e=e-s+i
if e%2==0:
print(e//2+s-i)
else:
print((e+1)//2+s-i)
else:
e=e-i+s
if e%2==0:
print(e//2)
else:
print((e+1)//2)
```
|
instruction
| 0
| 16,941
| 2
| 33,882
|
No
|
output
| 1
| 16,941
| 2
| 33,883
|
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
You play your favourite game yet another time. You chose the character you didn't play before. It has str points of strength and int points of intelligence. Also, at start, the character has exp free experience points you can invest either in strength or in intelligence (by investing one point you can either raise strength by 1 or raise intelligence by 1).
Since you'd like to make some fun you want to create a jock character, so it has more strength than intelligence points (resulting strength is strictly greater than the resulting intelligence).
Calculate the number of different character builds you can create (for the purpose of replayability) if you must invest all free points. Two character builds are different if their strength and/or intellect are different.
Input
The first line contains the single integer T (1 β€ T β€ 100) β the number of queries. Next T lines contain descriptions of queries β one per line.
This line contains three integers str, int and exp (1 β€ str, int β€ 10^8, 0 β€ exp β€ 10^8) β the initial strength and intelligence of the character and the number of free points, respectively.
Output
Print T integers β one per query. For each query print the number of different character builds you can create.
Example
Input
4
5 3 4
2 1 0
3 5 5
4 10 6
Output
3
1
2
0
Note
In the first query there are only three appropriate character builds: (str = 7, int = 5), (8, 4) and (9, 3). All other builds are either too smart or don't use all free points.
In the second query there is only one possible build: (2, 1).
In the third query there are two appropriate builds: (7, 6), (8, 5).
In the fourth query all builds have too much brains.
Submitted Solution:
```
from math import ceil
for _ in [0]*(int(input())):
s,i,e=map(int, input().split())
g=e//2+1
if e==0:
if s>i:
print(1)
else:
print(0)
elif s>i:
if (s-i)>g:
print(max((s+e)-(i+e),e))
else:
print(max((s+e)-(i+g),g,2 if e>1 else 1))
elif s==i:
print(ceil(e/2))
else:
print(max(ceil((e-(i-s))/2),0))
```
|
instruction
| 0
| 16,942
| 2
| 33,884
|
No
|
output
| 1
| 16,942
| 2
| 33,885
|
Provide tags and a correct Python 3 solution for this coding contest problem.
Anton is playing a very interesting computer game, but now he is stuck at one of the levels. To pass to the next level he has to prepare n potions.
Anton has a special kettle, that can prepare one potions in x seconds. Also, he knows spells of two types that can faster the process of preparing potions.
1. Spells of this type speed up the preparation time of one potion. There are m spells of this type, the i-th of them costs bi manapoints and changes the preparation time of each potion to ai instead of x.
2. Spells of this type immediately prepare some number of potions. There are k such spells, the i-th of them costs di manapoints and instantly create ci potions.
Anton can use no more than one spell of the first type and no more than one spell of the second type, and the total number of manapoints spent should not exceed s. Consider that all spells are used instantly and right before Anton starts to prepare potions.
Anton wants to get to the next level as fast as possible, so he is interested in the minimum number of time he needs to spent in order to prepare at least n potions.
Input
The first line of the input contains three integers n, m, k (1 β€ n β€ 2Β·109, 1 β€ m, k β€ 2Β·105) β the number of potions, Anton has to make, the number of spells of the first type and the number of spells of the second type.
The second line of the input contains two integers x and s (2 β€ x β€ 2Β·109, 1 β€ s β€ 2Β·109) β the initial number of seconds required to prepare one potion and the number of manapoints Anton can use.
The third line contains m integers ai (1 β€ ai < x) β the number of seconds it will take to prepare one potion if the i-th spell of the first type is used.
The fourth line contains m integers bi (1 β€ bi β€ 2Β·109) β the number of manapoints to use the i-th spell of the first type.
There are k integers ci (1 β€ ci β€ n) in the fifth line β the number of potions that will be immediately created if the i-th spell of the second type is used. It's guaranteed that ci are not decreasing, i.e. ci β€ cj if i < j.
The sixth line contains k integers di (1 β€ di β€ 2Β·109) β the number of manapoints required to use the i-th spell of the second type. It's guaranteed that di are not decreasing, i.e. di β€ dj if i < j.
Output
Print one integer β the minimum time one has to spent in order to prepare n potions.
Examples
Input
20 3 2
10 99
2 4 3
20 10 40
4 15
10 80
Output
20
Input
20 3 2
10 99
2 4 3
200 100 400
4 15
100 800
Output
200
Note
In the first sample, the optimum answer is to use the second spell of the first type that costs 10 manapoints. Thus, the preparation time of each potion changes to 4 seconds. Also, Anton should use the second spell of the second type to instantly prepare 15 potions spending 80 manapoints. The total number of manapoints used is 10 + 80 = 90, and the preparation time is 4Β·5 = 20 seconds (15 potions were prepared instantly, and the remaining 5 will take 4 seconds each).
In the second sample, Anton can't use any of the spells, so he just prepares 20 potions, spending 10 seconds on each of them and the answer is 20Β·10 = 200.
|
instruction
| 0
| 18,171
| 2
| 36,342
|
Tags: binary search, dp, greedy, two pointers
Correct Solution:
```
# -*- coding: utf-8 -*-
"""
Created on Tue Dec 25 23:51:52 2018
@author: Quaint Sun
"""
import bisect
n,m,k=map(int,input().split())
x,s=map(int,input().split())
a=list(map(int,input().split()))
b=list(map(int,input().split()))
c=list(map(int,input().split()))
d=list(map(int,input().split()))
a.append(x)
b.append(0)
ans=n*x
for i in range(m+1):
if b[i]>s:
continue
if d[0]>s-b[i]:
ans=min(ans,a[i]*n)
continue
t=bisect.bisect_right(d,s-b[i])-1
ans=min(ans,(n-c[t])*a[i])
print(ans)
```
|
output
| 1
| 18,171
| 2
| 36,343
|
Provide tags and a correct Python 3 solution for this coding contest problem.
Anton is playing a very interesting computer game, but now he is stuck at one of the levels. To pass to the next level he has to prepare n potions.
Anton has a special kettle, that can prepare one potions in x seconds. Also, he knows spells of two types that can faster the process of preparing potions.
1. Spells of this type speed up the preparation time of one potion. There are m spells of this type, the i-th of them costs bi manapoints and changes the preparation time of each potion to ai instead of x.
2. Spells of this type immediately prepare some number of potions. There are k such spells, the i-th of them costs di manapoints and instantly create ci potions.
Anton can use no more than one spell of the first type and no more than one spell of the second type, and the total number of manapoints spent should not exceed s. Consider that all spells are used instantly and right before Anton starts to prepare potions.
Anton wants to get to the next level as fast as possible, so he is interested in the minimum number of time he needs to spent in order to prepare at least n potions.
Input
The first line of the input contains three integers n, m, k (1 β€ n β€ 2Β·109, 1 β€ m, k β€ 2Β·105) β the number of potions, Anton has to make, the number of spells of the first type and the number of spells of the second type.
The second line of the input contains two integers x and s (2 β€ x β€ 2Β·109, 1 β€ s β€ 2Β·109) β the initial number of seconds required to prepare one potion and the number of manapoints Anton can use.
The third line contains m integers ai (1 β€ ai < x) β the number of seconds it will take to prepare one potion if the i-th spell of the first type is used.
The fourth line contains m integers bi (1 β€ bi β€ 2Β·109) β the number of manapoints to use the i-th spell of the first type.
There are k integers ci (1 β€ ci β€ n) in the fifth line β the number of potions that will be immediately created if the i-th spell of the second type is used. It's guaranteed that ci are not decreasing, i.e. ci β€ cj if i < j.
The sixth line contains k integers di (1 β€ di β€ 2Β·109) β the number of manapoints required to use the i-th spell of the second type. It's guaranteed that di are not decreasing, i.e. di β€ dj if i < j.
Output
Print one integer β the minimum time one has to spent in order to prepare n potions.
Examples
Input
20 3 2
10 99
2 4 3
20 10 40
4 15
10 80
Output
20
Input
20 3 2
10 99
2 4 3
200 100 400
4 15
100 800
Output
200
Note
In the first sample, the optimum answer is to use the second spell of the first type that costs 10 manapoints. Thus, the preparation time of each potion changes to 4 seconds. Also, Anton should use the second spell of the second type to instantly prepare 15 potions spending 80 manapoints. The total number of manapoints used is 10 + 80 = 90, and the preparation time is 4Β·5 = 20 seconds (15 potions were prepared instantly, and the remaining 5 will take 4 seconds each).
In the second sample, Anton can't use any of the spells, so he just prepares 20 potions, spending 10 seconds on each of them and the answer is 20Β·10 = 200.
|
instruction
| 0
| 18,172
| 2
| 36,344
|
Tags: binary search, dp, greedy, two pointers
Correct Solution:
```
s=input()
s1=s.split()
tot=int(s1[0])
s=input()
s1=s.split()
time=int(s1[0])
mon=int(s1[1])
s=input()
s1=s.split()
p1=[int(i) for i in s1]
s=input()
s1=s.split()
p1cost=[int(i) for i in s1]
s=input()
s1=s.split()
p2=[int(i) for i in s1]
s=input()
s1=s.split()
p2cost=[int(i) for i in s1]
def fun(cost):
global p2
global p2cost
l=0
r=len(p2)-1
while l<r:
mid=(l+r+1)//2
if p2cost[mid]>cost:
r=mid-1
else:
l=mid
mid=(l+r+1)//2
if p2cost[mid]>cost:
return(0)
else:
return(p2[mid])
minval=tot*time
for i in range(len(p1)):
if p1cost[i]<=mon:
minval=min(minval,(tot-fun(mon-p1cost[i]))*(p1[i]))
minval=min(minval,(tot-fun(mon))*time)
print(minval)
```
|
output
| 1
| 18,172
| 2
| 36,345
|
Provide tags and a correct Python 3 solution for this coding contest problem.
Anton is playing a very interesting computer game, but now he is stuck at one of the levels. To pass to the next level he has to prepare n potions.
Anton has a special kettle, that can prepare one potions in x seconds. Also, he knows spells of two types that can faster the process of preparing potions.
1. Spells of this type speed up the preparation time of one potion. There are m spells of this type, the i-th of them costs bi manapoints and changes the preparation time of each potion to ai instead of x.
2. Spells of this type immediately prepare some number of potions. There are k such spells, the i-th of them costs di manapoints and instantly create ci potions.
Anton can use no more than one spell of the first type and no more than one spell of the second type, and the total number of manapoints spent should not exceed s. Consider that all spells are used instantly and right before Anton starts to prepare potions.
Anton wants to get to the next level as fast as possible, so he is interested in the minimum number of time he needs to spent in order to prepare at least n potions.
Input
The first line of the input contains three integers n, m, k (1 β€ n β€ 2Β·109, 1 β€ m, k β€ 2Β·105) β the number of potions, Anton has to make, the number of spells of the first type and the number of spells of the second type.
The second line of the input contains two integers x and s (2 β€ x β€ 2Β·109, 1 β€ s β€ 2Β·109) β the initial number of seconds required to prepare one potion and the number of manapoints Anton can use.
The third line contains m integers ai (1 β€ ai < x) β the number of seconds it will take to prepare one potion if the i-th spell of the first type is used.
The fourth line contains m integers bi (1 β€ bi β€ 2Β·109) β the number of manapoints to use the i-th spell of the first type.
There are k integers ci (1 β€ ci β€ n) in the fifth line β the number of potions that will be immediately created if the i-th spell of the second type is used. It's guaranteed that ci are not decreasing, i.e. ci β€ cj if i < j.
The sixth line contains k integers di (1 β€ di β€ 2Β·109) β the number of manapoints required to use the i-th spell of the second type. It's guaranteed that di are not decreasing, i.e. di β€ dj if i < j.
Output
Print one integer β the minimum time one has to spent in order to prepare n potions.
Examples
Input
20 3 2
10 99
2 4 3
20 10 40
4 15
10 80
Output
20
Input
20 3 2
10 99
2 4 3
200 100 400
4 15
100 800
Output
200
Note
In the first sample, the optimum answer is to use the second spell of the first type that costs 10 manapoints. Thus, the preparation time of each potion changes to 4 seconds. Also, Anton should use the second spell of the second type to instantly prepare 15 potions spending 80 manapoints. The total number of manapoints used is 10 + 80 = 90, and the preparation time is 4Β·5 = 20 seconds (15 potions were prepared instantly, and the remaining 5 will take 4 seconds each).
In the second sample, Anton can't use any of the spells, so he just prepares 20 potions, spending 10 seconds on each of them and the answer is 20Β·10 = 200.
|
instruction
| 0
| 18,173
| 2
| 36,346
|
Tags: binary search, dp, greedy, two pointers
Correct Solution:
```
n, m, k = map(int, input().split())
x, s = map(int, input().split())
a = list(map(int, input().split()))
b = list(map(int, input().split()))
c = list(map(int, input().split()))
d = list(map(int, input().split()))
def binary_search(val):
l, r = 0, k-1
while (l <= r):
mid = l+r >> 1
if (d[mid] <= val):
l = mid+1
else:
r = mid-1
return l
res = n * x
for i in range(m):
idx = binary_search(s - b[i]) - 1
if (idx >= 0):
res = min(res, (n - c[idx]) * a[i])
idx = binary_search(s) - 1;
if (idx >= 0):
res = min(res, (n - c[idx]) * x);
for i in range(m):
if(b[i] <= s):
res = min(res, a[i] * n)
print(res)
```
|
output
| 1
| 18,173
| 2
| 36,347
|
Provide tags and a correct Python 3 solution for this coding contest problem.
Anton is playing a very interesting computer game, but now he is stuck at one of the levels. To pass to the next level he has to prepare n potions.
Anton has a special kettle, that can prepare one potions in x seconds. Also, he knows spells of two types that can faster the process of preparing potions.
1. Spells of this type speed up the preparation time of one potion. There are m spells of this type, the i-th of them costs bi manapoints and changes the preparation time of each potion to ai instead of x.
2. Spells of this type immediately prepare some number of potions. There are k such spells, the i-th of them costs di manapoints and instantly create ci potions.
Anton can use no more than one spell of the first type and no more than one spell of the second type, and the total number of manapoints spent should not exceed s. Consider that all spells are used instantly and right before Anton starts to prepare potions.
Anton wants to get to the next level as fast as possible, so he is interested in the minimum number of time he needs to spent in order to prepare at least n potions.
Input
The first line of the input contains three integers n, m, k (1 β€ n β€ 2Β·109, 1 β€ m, k β€ 2Β·105) β the number of potions, Anton has to make, the number of spells of the first type and the number of spells of the second type.
The second line of the input contains two integers x and s (2 β€ x β€ 2Β·109, 1 β€ s β€ 2Β·109) β the initial number of seconds required to prepare one potion and the number of manapoints Anton can use.
The third line contains m integers ai (1 β€ ai < x) β the number of seconds it will take to prepare one potion if the i-th spell of the first type is used.
The fourth line contains m integers bi (1 β€ bi β€ 2Β·109) β the number of manapoints to use the i-th spell of the first type.
There are k integers ci (1 β€ ci β€ n) in the fifth line β the number of potions that will be immediately created if the i-th spell of the second type is used. It's guaranteed that ci are not decreasing, i.e. ci β€ cj if i < j.
The sixth line contains k integers di (1 β€ di β€ 2Β·109) β the number of manapoints required to use the i-th spell of the second type. It's guaranteed that di are not decreasing, i.e. di β€ dj if i < j.
Output
Print one integer β the minimum time one has to spent in order to prepare n potions.
Examples
Input
20 3 2
10 99
2 4 3
20 10 40
4 15
10 80
Output
20
Input
20 3 2
10 99
2 4 3
200 100 400
4 15
100 800
Output
200
Note
In the first sample, the optimum answer is to use the second spell of the first type that costs 10 manapoints. Thus, the preparation time of each potion changes to 4 seconds. Also, Anton should use the second spell of the second type to instantly prepare 15 potions spending 80 manapoints. The total number of manapoints used is 10 + 80 = 90, and the preparation time is 4Β·5 = 20 seconds (15 potions were prepared instantly, and the remaining 5 will take 4 seconds each).
In the second sample, Anton can't use any of the spells, so he just prepares 20 potions, spending 10 seconds on each of them and the answer is 20Β·10 = 200.
|
instruction
| 0
| 18,174
| 2
| 36,348
|
Tags: binary search, dp, greedy, two pointers
Correct Solution:
```
import bisect
n, m, k = [int(i) for i in input().split()]
#n:potionNumber, m:firstSpellNumber, k:secondSpellNumber
x, s = [int(i) for i in input().split()]
#x:potion/seconds, s:manapointsNumber
timeOne = [int(i) for i in input().split()]
manaOne = [int(i) for i in input().split()]
numTwo = [int(i) for i in input().split()]
manaTwo = [int(i) for i in input().split()]
timeOne.append(x)
manaOne.append(0)
result = x*n
for i in range(len(timeOne)) :
if manaOne[i] > s:
continue
if s-manaOne[i] < manaTwo[0]:
result = min(result, n*timeOne[i])
continue
t = bisect.bisect_right(manaTwo, s-manaOne[i], 0, len(manaTwo)) - 1
result = min(result, (n-numTwo[t])*timeOne[i])
print(result)
```
|
output
| 1
| 18,174
| 2
| 36,349
|
Provide tags and a correct Python 3 solution for this coding contest problem.
Anton is playing a very interesting computer game, but now he is stuck at one of the levels. To pass to the next level he has to prepare n potions.
Anton has a special kettle, that can prepare one potions in x seconds. Also, he knows spells of two types that can faster the process of preparing potions.
1. Spells of this type speed up the preparation time of one potion. There are m spells of this type, the i-th of them costs bi manapoints and changes the preparation time of each potion to ai instead of x.
2. Spells of this type immediately prepare some number of potions. There are k such spells, the i-th of them costs di manapoints and instantly create ci potions.
Anton can use no more than one spell of the first type and no more than one spell of the second type, and the total number of manapoints spent should not exceed s. Consider that all spells are used instantly and right before Anton starts to prepare potions.
Anton wants to get to the next level as fast as possible, so he is interested in the minimum number of time he needs to spent in order to prepare at least n potions.
Input
The first line of the input contains three integers n, m, k (1 β€ n β€ 2Β·109, 1 β€ m, k β€ 2Β·105) β the number of potions, Anton has to make, the number of spells of the first type and the number of spells of the second type.
The second line of the input contains two integers x and s (2 β€ x β€ 2Β·109, 1 β€ s β€ 2Β·109) β the initial number of seconds required to prepare one potion and the number of manapoints Anton can use.
The third line contains m integers ai (1 β€ ai < x) β the number of seconds it will take to prepare one potion if the i-th spell of the first type is used.
The fourth line contains m integers bi (1 β€ bi β€ 2Β·109) β the number of manapoints to use the i-th spell of the first type.
There are k integers ci (1 β€ ci β€ n) in the fifth line β the number of potions that will be immediately created if the i-th spell of the second type is used. It's guaranteed that ci are not decreasing, i.e. ci β€ cj if i < j.
The sixth line contains k integers di (1 β€ di β€ 2Β·109) β the number of manapoints required to use the i-th spell of the second type. It's guaranteed that di are not decreasing, i.e. di β€ dj if i < j.
Output
Print one integer β the minimum time one has to spent in order to prepare n potions.
Examples
Input
20 3 2
10 99
2 4 3
20 10 40
4 15
10 80
Output
20
Input
20 3 2
10 99
2 4 3
200 100 400
4 15
100 800
Output
200
Note
In the first sample, the optimum answer is to use the second spell of the first type that costs 10 manapoints. Thus, the preparation time of each potion changes to 4 seconds. Also, Anton should use the second spell of the second type to instantly prepare 15 potions spending 80 manapoints. The total number of manapoints used is 10 + 80 = 90, and the preparation time is 4Β·5 = 20 seconds (15 potions were prepared instantly, and the remaining 5 will take 4 seconds each).
In the second sample, Anton can't use any of the spells, so he just prepares 20 potions, spending 10 seconds on each of them and the answer is 20Β·10 = 200.
|
instruction
| 0
| 18,175
| 2
| 36,350
|
Tags: binary search, dp, greedy, two pointers
Correct Solution:
```
from bisect import *
n,m,k=map(int,input().split())
x,s=map(int,input().split())
red=list(map(int,input().split()))
c1=list(map(int,input().split()))
c1.append(0)
red.append(x)
pot=list(map(int,input().split()))
c2=list(map(int,input().split()))
from collections import *
al=defaultdict(int)
for i in range(len(c2)):
al[c2[i]]=pot[i]
total=x*n
for i in range(len(red)):
if(c1[i]<=s):
left=s-c1[i]
total=min(total,n*red[i])
q=bisect_left(c2,left)
if(len(c2)==q):
q-=1
elif(c2[q]!=left):
q-=1
if(q<0):
continue;
item=al[c2[q]]
total=min((max(0,n-item)*red[i]),total)
print(total)
```
|
output
| 1
| 18,175
| 2
| 36,351
|
Provide tags and a correct Python 3 solution for this coding contest problem.
Anton is playing a very interesting computer game, but now he is stuck at one of the levels. To pass to the next level he has to prepare n potions.
Anton has a special kettle, that can prepare one potions in x seconds. Also, he knows spells of two types that can faster the process of preparing potions.
1. Spells of this type speed up the preparation time of one potion. There are m spells of this type, the i-th of them costs bi manapoints and changes the preparation time of each potion to ai instead of x.
2. Spells of this type immediately prepare some number of potions. There are k such spells, the i-th of them costs di manapoints and instantly create ci potions.
Anton can use no more than one spell of the first type and no more than one spell of the second type, and the total number of manapoints spent should not exceed s. Consider that all spells are used instantly and right before Anton starts to prepare potions.
Anton wants to get to the next level as fast as possible, so he is interested in the minimum number of time he needs to spent in order to prepare at least n potions.
Input
The first line of the input contains three integers n, m, k (1 β€ n β€ 2Β·109, 1 β€ m, k β€ 2Β·105) β the number of potions, Anton has to make, the number of spells of the first type and the number of spells of the second type.
The second line of the input contains two integers x and s (2 β€ x β€ 2Β·109, 1 β€ s β€ 2Β·109) β the initial number of seconds required to prepare one potion and the number of manapoints Anton can use.
The third line contains m integers ai (1 β€ ai < x) β the number of seconds it will take to prepare one potion if the i-th spell of the first type is used.
The fourth line contains m integers bi (1 β€ bi β€ 2Β·109) β the number of manapoints to use the i-th spell of the first type.
There are k integers ci (1 β€ ci β€ n) in the fifth line β the number of potions that will be immediately created if the i-th spell of the second type is used. It's guaranteed that ci are not decreasing, i.e. ci β€ cj if i < j.
The sixth line contains k integers di (1 β€ di β€ 2Β·109) β the number of manapoints required to use the i-th spell of the second type. It's guaranteed that di are not decreasing, i.e. di β€ dj if i < j.
Output
Print one integer β the minimum time one has to spent in order to prepare n potions.
Examples
Input
20 3 2
10 99
2 4 3
20 10 40
4 15
10 80
Output
20
Input
20 3 2
10 99
2 4 3
200 100 400
4 15
100 800
Output
200
Note
In the first sample, the optimum answer is to use the second spell of the first type that costs 10 manapoints. Thus, the preparation time of each potion changes to 4 seconds. Also, Anton should use the second spell of the second type to instantly prepare 15 potions spending 80 manapoints. The total number of manapoints used is 10 + 80 = 90, and the preparation time is 4Β·5 = 20 seconds (15 potions were prepared instantly, and the remaining 5 will take 4 seconds each).
In the second sample, Anton can't use any of the spells, so he just prepares 20 potions, spending 10 seconds on each of them and the answer is 20Β·10 = 200.
|
instruction
| 0
| 18,176
| 2
| 36,352
|
Tags: binary search, dp, greedy, two pointers
Correct Solution:
```
n,m,k = list(map(int,input().split()))
x,s = list(map(int,input().split()))
a_time = list(map(int,input().split()))
a_cost = list(map(int,input().split()))
b_num = list(map(int,input().split()))
b_cost = list(map(int,input().split()))
def binary_search(manapoints):
global k,b_cost
l = 0; r = k-1; pos = -1
while (l <= r):
mid = int((l+r)/2)
if (b_cost[mid] <= manapoints):
l = mid+1; pos = mid;
else :
r = mid-1
return pos
res = n*x
pos = binary_search(s)
if (pos >= 0): res = min(res,(n-b_num[pos])*x);
for i in range(m):
if (a_cost[i] > s): continue;
rest = s-a_cost[i]
pos = binary_search(rest)
if (pos >= 0): res = min(res,(n-b_num[pos])*a_time[i])
else : res = min(res,n*a_time[i])
print(res)
```
|
output
| 1
| 18,176
| 2
| 36,353
|
Provide tags and a correct Python 3 solution for this coding contest problem.
Anton is playing a very interesting computer game, but now he is stuck at one of the levels. To pass to the next level he has to prepare n potions.
Anton has a special kettle, that can prepare one potions in x seconds. Also, he knows spells of two types that can faster the process of preparing potions.
1. Spells of this type speed up the preparation time of one potion. There are m spells of this type, the i-th of them costs bi manapoints and changes the preparation time of each potion to ai instead of x.
2. Spells of this type immediately prepare some number of potions. There are k such spells, the i-th of them costs di manapoints and instantly create ci potions.
Anton can use no more than one spell of the first type and no more than one spell of the second type, and the total number of manapoints spent should not exceed s. Consider that all spells are used instantly and right before Anton starts to prepare potions.
Anton wants to get to the next level as fast as possible, so he is interested in the minimum number of time he needs to spent in order to prepare at least n potions.
Input
The first line of the input contains three integers n, m, k (1 β€ n β€ 2Β·109, 1 β€ m, k β€ 2Β·105) β the number of potions, Anton has to make, the number of spells of the first type and the number of spells of the second type.
The second line of the input contains two integers x and s (2 β€ x β€ 2Β·109, 1 β€ s β€ 2Β·109) β the initial number of seconds required to prepare one potion and the number of manapoints Anton can use.
The third line contains m integers ai (1 β€ ai < x) β the number of seconds it will take to prepare one potion if the i-th spell of the first type is used.
The fourth line contains m integers bi (1 β€ bi β€ 2Β·109) β the number of manapoints to use the i-th spell of the first type.
There are k integers ci (1 β€ ci β€ n) in the fifth line β the number of potions that will be immediately created if the i-th spell of the second type is used. It's guaranteed that ci are not decreasing, i.e. ci β€ cj if i < j.
The sixth line contains k integers di (1 β€ di β€ 2Β·109) β the number of manapoints required to use the i-th spell of the second type. It's guaranteed that di are not decreasing, i.e. di β€ dj if i < j.
Output
Print one integer β the minimum time one has to spent in order to prepare n potions.
Examples
Input
20 3 2
10 99
2 4 3
20 10 40
4 15
10 80
Output
20
Input
20 3 2
10 99
2 4 3
200 100 400
4 15
100 800
Output
200
Note
In the first sample, the optimum answer is to use the second spell of the first type that costs 10 manapoints. Thus, the preparation time of each potion changes to 4 seconds. Also, Anton should use the second spell of the second type to instantly prepare 15 potions spending 80 manapoints. The total number of manapoints used is 10 + 80 = 90, and the preparation time is 4Β·5 = 20 seconds (15 potions were prepared instantly, and the remaining 5 will take 4 seconds each).
In the second sample, Anton can't use any of the spells, so he just prepares 20 potions, spending 10 seconds on each of them and the answer is 20Β·10 = 200.
|
instruction
| 0
| 18,177
| 2
| 36,354
|
Tags: binary search, dp, greedy, two pointers
Correct Solution:
```
def R():
return map(int, input().strip().split())
n, m, k = R()
x, s = R()
t1 = list(R())
m1 = list(R())
t2 = list(R())
m2 = list(R())
h = []
for i in range(len(m1)):
if s-m1[i] >= 0:
h.append([t1[i], s-m1[i]])
h.sort(key = lambda x: x[1])
so_far = None
j = 0
ans = n*x
for i in range(len(h)):
while j < len(m2) and m2[j] <= h[i][1]:
so_far = j
j += 1
if so_far is not None:
ans = min(ans, (n-t2[so_far])*h[i][0])
ans = min(ans, n*h[i][0])
for i in range(len(m2)):
if m2[i] <= s:
ans = min(ans, (n-t2[i])*x)
print(ans)
```
|
output
| 1
| 18,177
| 2
| 36,355
|
Provide tags and a correct Python 3 solution for this coding contest problem.
Anton is playing a very interesting computer game, but now he is stuck at one of the levels. To pass to the next level he has to prepare n potions.
Anton has a special kettle, that can prepare one potions in x seconds. Also, he knows spells of two types that can faster the process of preparing potions.
1. Spells of this type speed up the preparation time of one potion. There are m spells of this type, the i-th of them costs bi manapoints and changes the preparation time of each potion to ai instead of x.
2. Spells of this type immediately prepare some number of potions. There are k such spells, the i-th of them costs di manapoints and instantly create ci potions.
Anton can use no more than one spell of the first type and no more than one spell of the second type, and the total number of manapoints spent should not exceed s. Consider that all spells are used instantly and right before Anton starts to prepare potions.
Anton wants to get to the next level as fast as possible, so he is interested in the minimum number of time he needs to spent in order to prepare at least n potions.
Input
The first line of the input contains three integers n, m, k (1 β€ n β€ 2Β·109, 1 β€ m, k β€ 2Β·105) β the number of potions, Anton has to make, the number of spells of the first type and the number of spells of the second type.
The second line of the input contains two integers x and s (2 β€ x β€ 2Β·109, 1 β€ s β€ 2Β·109) β the initial number of seconds required to prepare one potion and the number of manapoints Anton can use.
The third line contains m integers ai (1 β€ ai < x) β the number of seconds it will take to prepare one potion if the i-th spell of the first type is used.
The fourth line contains m integers bi (1 β€ bi β€ 2Β·109) β the number of manapoints to use the i-th spell of the first type.
There are k integers ci (1 β€ ci β€ n) in the fifth line β the number of potions that will be immediately created if the i-th spell of the second type is used. It's guaranteed that ci are not decreasing, i.e. ci β€ cj if i < j.
The sixth line contains k integers di (1 β€ di β€ 2Β·109) β the number of manapoints required to use the i-th spell of the second type. It's guaranteed that di are not decreasing, i.e. di β€ dj if i < j.
Output
Print one integer β the minimum time one has to spent in order to prepare n potions.
Examples
Input
20 3 2
10 99
2 4 3
20 10 40
4 15
10 80
Output
20
Input
20 3 2
10 99
2 4 3
200 100 400
4 15
100 800
Output
200
Note
In the first sample, the optimum answer is to use the second spell of the first type that costs 10 manapoints. Thus, the preparation time of each potion changes to 4 seconds. Also, Anton should use the second spell of the second type to instantly prepare 15 potions spending 80 manapoints. The total number of manapoints used is 10 + 80 = 90, and the preparation time is 4Β·5 = 20 seconds (15 potions were prepared instantly, and the remaining 5 will take 4 seconds each).
In the second sample, Anton can't use any of the spells, so he just prepares 20 potions, spending 10 seconds on each of them and the answer is 20Β·10 = 200.
|
instruction
| 0
| 18,178
| 2
| 36,356
|
Tags: binary search, dp, greedy, two pointers
Correct Solution:
```
def max_search(lis,l,r,value):
if r>=l:
mid = l + (r-l)//2
if lis[mid] > value:
return max_search(lis,l,mid-1,value)
else:
return max_search(lis,mid+1,r,value)
else:
return l-1
n,m,k = map(int,input().split())
x,s = map(int,input().split())
lis1 = [int(item) for item in input().split()]
cost1 = [int(item) for item in input().split()]
lis2 = [int(item) for item in input().split()]
cost2 = [int(item) for item in input().split()]
ans = []
ans.append(x*n)
temp = max_search(cost2,0,k-1,s)
if temp >= 0:
ans.append(x*max((n-lis2[temp]),0))
for i in range(m):
if cost1[i] <= s:
x = lis1[i]
temps = s - cost1[i]
temp = max_search(cost2,0,k-1,temps)
if temp >= 0:
ans.append(x*max((n-lis2[temp]),0))
else:
ans.append(x*n)
print(min(ans))
```
|
output
| 1
| 18,178
| 2
| 36,357
|
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
Anton is playing a very interesting computer game, but now he is stuck at one of the levels. To pass to the next level he has to prepare n potions.
Anton has a special kettle, that can prepare one potions in x seconds. Also, he knows spells of two types that can faster the process of preparing potions.
1. Spells of this type speed up the preparation time of one potion. There are m spells of this type, the i-th of them costs bi manapoints and changes the preparation time of each potion to ai instead of x.
2. Spells of this type immediately prepare some number of potions. There are k such spells, the i-th of them costs di manapoints and instantly create ci potions.
Anton can use no more than one spell of the first type and no more than one spell of the second type, and the total number of manapoints spent should not exceed s. Consider that all spells are used instantly and right before Anton starts to prepare potions.
Anton wants to get to the next level as fast as possible, so he is interested in the minimum number of time he needs to spent in order to prepare at least n potions.
Input
The first line of the input contains three integers n, m, k (1 β€ n β€ 2Β·109, 1 β€ m, k β€ 2Β·105) β the number of potions, Anton has to make, the number of spells of the first type and the number of spells of the second type.
The second line of the input contains two integers x and s (2 β€ x β€ 2Β·109, 1 β€ s β€ 2Β·109) β the initial number of seconds required to prepare one potion and the number of manapoints Anton can use.
The third line contains m integers ai (1 β€ ai < x) β the number of seconds it will take to prepare one potion if the i-th spell of the first type is used.
The fourth line contains m integers bi (1 β€ bi β€ 2Β·109) β the number of manapoints to use the i-th spell of the first type.
There are k integers ci (1 β€ ci β€ n) in the fifth line β the number of potions that will be immediately created if the i-th spell of the second type is used. It's guaranteed that ci are not decreasing, i.e. ci β€ cj if i < j.
The sixth line contains k integers di (1 β€ di β€ 2Β·109) β the number of manapoints required to use the i-th spell of the second type. It's guaranteed that di are not decreasing, i.e. di β€ dj if i < j.
Output
Print one integer β the minimum time one has to spent in order to prepare n potions.
Examples
Input
20 3 2
10 99
2 4 3
20 10 40
4 15
10 80
Output
20
Input
20 3 2
10 99
2 4 3
200 100 400
4 15
100 800
Output
200
Note
In the first sample, the optimum answer is to use the second spell of the first type that costs 10 manapoints. Thus, the preparation time of each potion changes to 4 seconds. Also, Anton should use the second spell of the second type to instantly prepare 15 potions spending 80 manapoints. The total number of manapoints used is 10 + 80 = 90, and the preparation time is 4Β·5 = 20 seconds (15 potions were prepared instantly, and the remaining 5 will take 4 seconds each).
In the second sample, Anton can't use any of the spells, so he just prepares 20 potions, spending 10 seconds on each of them and the answer is 20Β·10 = 200.
Submitted Solution:
```
from sys import stdin
from sys import stdout
n, m, k = (int(x) for x in stdin.readline()[:-1].split())
x, s = (int(x) for x in stdin.readline()[:-1].split())
a = [int(x) for x in stdin.readline()[:-1].split()]
b = [int(x) for x in stdin.readline()[:-1].split()]
c = [int(x) for x in stdin.readline()[:-1].split()]
d = [int(x) for x in stdin.readline()[:-1].split()]
c.reverse()
d.reverse()
spell1 = sorted(zip(b, a))
massimi = []
for i in range(len(spell1)):
if spell1[i][0] <= s and (i == 0 or spell1[i][1] < massimi[i-1]):
massimi.append(spell1[i][1])
elif i != 0 and (spell1[i][0] > s or spell1[i][1] >= massimi[i-1]):
massimi.append(massimi[i-1])
else:
massimi.append(x)
# print(massimi)
ans = n*massimi[-1]
last = 0
for di, ci in zip(d, c):
low = last
high = len(spell1)
mid = (high + low)//2
delta = s-di
# print(delta)
if delta < 0:
continue
index = -1
# print((di, ci, high, low))
while high-low > 1:
# print((' ', high-low))
if spell1[mid][0] > delta:
high = mid-1
mid = (high + low)//2
elif ((spell1[mid][0] <= delta and mid == len(spell1)-1)
or (spell1[mid][0] <= delta and spell1[mid+1][0] > delta)):
index = mid
break
elif spell1[mid][0] <= delta and spell1[mid+1][0] <= delta:
low = mid
mid = (high + low)//2
# print((di, ci, mid))
if high-low == 1:
if 0 <= high < m and spell1[high][0] <= delta:
index = high
elif 0 <= low < m and spell1[low][0] <= delta:
index = low
elif high-low == 0 and spell1[low][0] <= delta:
index = low
# print('index' + str(index))
tentativo = ans
if index == -1:
tentativo = (n-ci)*x
else:
tentativo = (n-ci)*massimi[index]
if tentativo < ans:
ans = tentativo
last = index if index > -1 else 0
# print(last)
# print(zip(d, c))
# print(massimi)
# print(spell1)
stdout.write(str(ans))
```
|
instruction
| 0
| 18,179
| 2
| 36,358
|
Yes
|
output
| 1
| 18,179
| 2
| 36,359
|
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
Anton is playing a very interesting computer game, but now he is stuck at one of the levels. To pass to the next level he has to prepare n potions.
Anton has a special kettle, that can prepare one potions in x seconds. Also, he knows spells of two types that can faster the process of preparing potions.
1. Spells of this type speed up the preparation time of one potion. There are m spells of this type, the i-th of them costs bi manapoints and changes the preparation time of each potion to ai instead of x.
2. Spells of this type immediately prepare some number of potions. There are k such spells, the i-th of them costs di manapoints and instantly create ci potions.
Anton can use no more than one spell of the first type and no more than one spell of the second type, and the total number of manapoints spent should not exceed s. Consider that all spells are used instantly and right before Anton starts to prepare potions.
Anton wants to get to the next level as fast as possible, so he is interested in the minimum number of time he needs to spent in order to prepare at least n potions.
Input
The first line of the input contains three integers n, m, k (1 β€ n β€ 2Β·109, 1 β€ m, k β€ 2Β·105) β the number of potions, Anton has to make, the number of spells of the first type and the number of spells of the second type.
The second line of the input contains two integers x and s (2 β€ x β€ 2Β·109, 1 β€ s β€ 2Β·109) β the initial number of seconds required to prepare one potion and the number of manapoints Anton can use.
The third line contains m integers ai (1 β€ ai < x) β the number of seconds it will take to prepare one potion if the i-th spell of the first type is used.
The fourth line contains m integers bi (1 β€ bi β€ 2Β·109) β the number of manapoints to use the i-th spell of the first type.
There are k integers ci (1 β€ ci β€ n) in the fifth line β the number of potions that will be immediately created if the i-th spell of the second type is used. It's guaranteed that ci are not decreasing, i.e. ci β€ cj if i < j.
The sixth line contains k integers di (1 β€ di β€ 2Β·109) β the number of manapoints required to use the i-th spell of the second type. It's guaranteed that di are not decreasing, i.e. di β€ dj if i < j.
Output
Print one integer β the minimum time one has to spent in order to prepare n potions.
Examples
Input
20 3 2
10 99
2 4 3
20 10 40
4 15
10 80
Output
20
Input
20 3 2
10 99
2 4 3
200 100 400
4 15
100 800
Output
200
Note
In the first sample, the optimum answer is to use the second spell of the first type that costs 10 manapoints. Thus, the preparation time of each potion changes to 4 seconds. Also, Anton should use the second spell of the second type to instantly prepare 15 potions spending 80 manapoints. The total number of manapoints used is 10 + 80 = 90, and the preparation time is 4Β·5 = 20 seconds (15 potions were prepared instantly, and the remaining 5 will take 4 seconds each).
In the second sample, Anton can't use any of the spells, so he just prepares 20 potions, spending 10 seconds on each of them and the answer is 20Β·10 = 200.
Submitted Solution:
```
import sys
import bisect
while True:
try:
n,m,k=[int(i) for i in input().split()]
x,s=[int(i) for i in input().split()]
ans=x*n
a=[int(i) for i in input().split()]
b=[int(i) for i in input().split()]
c=[int(i) for i in input().split()]
d=[int(i) for i in input().split()]
a.append(x)
b.append(0)
for i in range(m+1):
if b[i]>s:
continue
if s-b[i]<d[0]:
ans=min(ans,a[i]*n)
continue
t=bisect.bisect_right(d,s-b[i])-1
ans=min(ans,(n-c[t])*a[i])
print(ans)
except EOFError:
break
```
|
instruction
| 0
| 18,180
| 2
| 36,360
|
Yes
|
output
| 1
| 18,180
| 2
| 36,361
|
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
Anton is playing a very interesting computer game, but now he is stuck at one of the levels. To pass to the next level he has to prepare n potions.
Anton has a special kettle, that can prepare one potions in x seconds. Also, he knows spells of two types that can faster the process of preparing potions.
1. Spells of this type speed up the preparation time of one potion. There are m spells of this type, the i-th of them costs bi manapoints and changes the preparation time of each potion to ai instead of x.
2. Spells of this type immediately prepare some number of potions. There are k such spells, the i-th of them costs di manapoints and instantly create ci potions.
Anton can use no more than one spell of the first type and no more than one spell of the second type, and the total number of manapoints spent should not exceed s. Consider that all spells are used instantly and right before Anton starts to prepare potions.
Anton wants to get to the next level as fast as possible, so he is interested in the minimum number of time he needs to spent in order to prepare at least n potions.
Input
The first line of the input contains three integers n, m, k (1 β€ n β€ 2Β·109, 1 β€ m, k β€ 2Β·105) β the number of potions, Anton has to make, the number of spells of the first type and the number of spells of the second type.
The second line of the input contains two integers x and s (2 β€ x β€ 2Β·109, 1 β€ s β€ 2Β·109) β the initial number of seconds required to prepare one potion and the number of manapoints Anton can use.
The third line contains m integers ai (1 β€ ai < x) β the number of seconds it will take to prepare one potion if the i-th spell of the first type is used.
The fourth line contains m integers bi (1 β€ bi β€ 2Β·109) β the number of manapoints to use the i-th spell of the first type.
There are k integers ci (1 β€ ci β€ n) in the fifth line β the number of potions that will be immediately created if the i-th spell of the second type is used. It's guaranteed that ci are not decreasing, i.e. ci β€ cj if i < j.
The sixth line contains k integers di (1 β€ di β€ 2Β·109) β the number of manapoints required to use the i-th spell of the second type. It's guaranteed that di are not decreasing, i.e. di β€ dj if i < j.
Output
Print one integer β the minimum time one has to spent in order to prepare n potions.
Examples
Input
20 3 2
10 99
2 4 3
20 10 40
4 15
10 80
Output
20
Input
20 3 2
10 99
2 4 3
200 100 400
4 15
100 800
Output
200
Note
In the first sample, the optimum answer is to use the second spell of the first type that costs 10 manapoints. Thus, the preparation time of each potion changes to 4 seconds. Also, Anton should use the second spell of the second type to instantly prepare 15 potions spending 80 manapoints. The total number of manapoints used is 10 + 80 = 90, and the preparation time is 4Β·5 = 20 seconds (15 potions were prepared instantly, and the remaining 5 will take 4 seconds each).
In the second sample, Anton can't use any of the spells, so he just prepares 20 potions, spending 10 seconds on each of them and the answer is 20Β·10 = 200.
Submitted Solution:
```
import bisect
n,m,k=[int(i) for i in input().split()]
x,s=[int(i) for i in input().split()]
a=[int(i) for i in input().split()]+[x]
b=[int(i) for i in input().split()]+[0]
c=[0]+[int(i) for i in input().split()]
d=[0]+[int(i) for i in input().split()]
time=n*x
for m1 in range(m+1):
if b[m1]>s:
continue
else:
t=bisect.bisect_right(d,s-b[m1])-1
time=min(time,(n-c[t])*a[m1])
if time>0:
print(time)
else:
print('0')
```
|
instruction
| 0
| 18,181
| 2
| 36,362
|
Yes
|
output
| 1
| 18,181
| 2
| 36,363
|
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
Anton is playing a very interesting computer game, but now he is stuck at one of the levels. To pass to the next level he has to prepare n potions.
Anton has a special kettle, that can prepare one potions in x seconds. Also, he knows spells of two types that can faster the process of preparing potions.
1. Spells of this type speed up the preparation time of one potion. There are m spells of this type, the i-th of them costs bi manapoints and changes the preparation time of each potion to ai instead of x.
2. Spells of this type immediately prepare some number of potions. There are k such spells, the i-th of them costs di manapoints and instantly create ci potions.
Anton can use no more than one spell of the first type and no more than one spell of the second type, and the total number of manapoints spent should not exceed s. Consider that all spells are used instantly and right before Anton starts to prepare potions.
Anton wants to get to the next level as fast as possible, so he is interested in the minimum number of time he needs to spent in order to prepare at least n potions.
Input
The first line of the input contains three integers n, m, k (1 β€ n β€ 2Β·109, 1 β€ m, k β€ 2Β·105) β the number of potions, Anton has to make, the number of spells of the first type and the number of spells of the second type.
The second line of the input contains two integers x and s (2 β€ x β€ 2Β·109, 1 β€ s β€ 2Β·109) β the initial number of seconds required to prepare one potion and the number of manapoints Anton can use.
The third line contains m integers ai (1 β€ ai < x) β the number of seconds it will take to prepare one potion if the i-th spell of the first type is used.
The fourth line contains m integers bi (1 β€ bi β€ 2Β·109) β the number of manapoints to use the i-th spell of the first type.
There are k integers ci (1 β€ ci β€ n) in the fifth line β the number of potions that will be immediately created if the i-th spell of the second type is used. It's guaranteed that ci are not decreasing, i.e. ci β€ cj if i < j.
The sixth line contains k integers di (1 β€ di β€ 2Β·109) β the number of manapoints required to use the i-th spell of the second type. It's guaranteed that di are not decreasing, i.e. di β€ dj if i < j.
Output
Print one integer β the minimum time one has to spent in order to prepare n potions.
Examples
Input
20 3 2
10 99
2 4 3
20 10 40
4 15
10 80
Output
20
Input
20 3 2
10 99
2 4 3
200 100 400
4 15
100 800
Output
200
Note
In the first sample, the optimum answer is to use the second spell of the first type that costs 10 manapoints. Thus, the preparation time of each potion changes to 4 seconds. Also, Anton should use the second spell of the second type to instantly prepare 15 potions spending 80 manapoints. The total number of manapoints used is 10 + 80 = 90, and the preparation time is 4Β·5 = 20 seconds (15 potions were prepared instantly, and the remaining 5 will take 4 seconds each).
In the second sample, Anton can't use any of the spells, so he just prepares 20 potions, spending 10 seconds on each of them and the answer is 20Β·10 = 200.
Submitted Solution:
```
import bisect
n,m,k = map(int,input().split())
x,s = map(int,input().split())
a = [int(i) for i in input().split()]
b = [int(i) for i in input().split()]
c = [int(i) for i in input().split()]
d = [int(i) for i in input().split()]
a.append(x)
b.append(0)
ans = n*x
for i in range(m+1):
if b[i] > s:
continue
if b[i] + d[0] > s:
ans = min(ans,n*a[i])
continue
t = bisect.bisect_right(d,s-b[i])-1
ans = min(ans,(n-c[t])*a[i])
print(ans)
```
|
instruction
| 0
| 18,182
| 2
| 36,364
|
Yes
|
output
| 1
| 18,182
| 2
| 36,365
|
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
Anton is playing a very interesting computer game, but now he is stuck at one of the levels. To pass to the next level he has to prepare n potions.
Anton has a special kettle, that can prepare one potions in x seconds. Also, he knows spells of two types that can faster the process of preparing potions.
1. Spells of this type speed up the preparation time of one potion. There are m spells of this type, the i-th of them costs bi manapoints and changes the preparation time of each potion to ai instead of x.
2. Spells of this type immediately prepare some number of potions. There are k such spells, the i-th of them costs di manapoints and instantly create ci potions.
Anton can use no more than one spell of the first type and no more than one spell of the second type, and the total number of manapoints spent should not exceed s. Consider that all spells are used instantly and right before Anton starts to prepare potions.
Anton wants to get to the next level as fast as possible, so he is interested in the minimum number of time he needs to spent in order to prepare at least n potions.
Input
The first line of the input contains three integers n, m, k (1 β€ n β€ 2Β·109, 1 β€ m, k β€ 2Β·105) β the number of potions, Anton has to make, the number of spells of the first type and the number of spells of the second type.
The second line of the input contains two integers x and s (2 β€ x β€ 2Β·109, 1 β€ s β€ 2Β·109) β the initial number of seconds required to prepare one potion and the number of manapoints Anton can use.
The third line contains m integers ai (1 β€ ai < x) β the number of seconds it will take to prepare one potion if the i-th spell of the first type is used.
The fourth line contains m integers bi (1 β€ bi β€ 2Β·109) β the number of manapoints to use the i-th spell of the first type.
There are k integers ci (1 β€ ci β€ n) in the fifth line β the number of potions that will be immediately created if the i-th spell of the second type is used. It's guaranteed that ci are not decreasing, i.e. ci β€ cj if i < j.
The sixth line contains k integers di (1 β€ di β€ 2Β·109) β the number of manapoints required to use the i-th spell of the second type. It's guaranteed that di are not decreasing, i.e. di β€ dj if i < j.
Output
Print one integer β the minimum time one has to spent in order to prepare n potions.
Examples
Input
20 3 2
10 99
2 4 3
20 10 40
4 15
10 80
Output
20
Input
20 3 2
10 99
2 4 3
200 100 400
4 15
100 800
Output
200
Note
In the first sample, the optimum answer is to use the second spell of the first type that costs 10 manapoints. Thus, the preparation time of each potion changes to 4 seconds. Also, Anton should use the second spell of the second type to instantly prepare 15 potions spending 80 manapoints. The total number of manapoints used is 10 + 80 = 90, and the preparation time is 4Β·5 = 20 seconds (15 potions were prepared instantly, and the remaining 5 will take 4 seconds each).
In the second sample, Anton can't use any of the spells, so he just prepares 20 potions, spending 10 seconds on each of them and the answer is 20Β·10 = 200.
Submitted Solution:
```
import sys
input=sys.stdin.readline
n,m,k=map(int,input().split())
x,s=map(int,input().split())
a=list(map(int,input().split()))
b=list(map(int,input().split()))
c=[0]+list(map(int,input().split()))
d=[0]+list(map(int,input().split()))
arr=sorted(list(zip(a,b)),key=lambda x:-x[1])
ans=n*x
j=0
for aa,bb in arr:
while j<=k and d[j]+bb<=s:
j+=1
if j==0:
continue
ans=min(ans,aa*(n-c[j-1]))
print(ans)
```
|
instruction
| 0
| 18,183
| 2
| 36,366
|
No
|
output
| 1
| 18,183
| 2
| 36,367
|
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
Anton is playing a very interesting computer game, but now he is stuck at one of the levels. To pass to the next level he has to prepare n potions.
Anton has a special kettle, that can prepare one potions in x seconds. Also, he knows spells of two types that can faster the process of preparing potions.
1. Spells of this type speed up the preparation time of one potion. There are m spells of this type, the i-th of them costs bi manapoints and changes the preparation time of each potion to ai instead of x.
2. Spells of this type immediately prepare some number of potions. There are k such spells, the i-th of them costs di manapoints and instantly create ci potions.
Anton can use no more than one spell of the first type and no more than one spell of the second type, and the total number of manapoints spent should not exceed s. Consider that all spells are used instantly and right before Anton starts to prepare potions.
Anton wants to get to the next level as fast as possible, so he is interested in the minimum number of time he needs to spent in order to prepare at least n potions.
Input
The first line of the input contains three integers n, m, k (1 β€ n β€ 2Β·109, 1 β€ m, k β€ 2Β·105) β the number of potions, Anton has to make, the number of spells of the first type and the number of spells of the second type.
The second line of the input contains two integers x and s (2 β€ x β€ 2Β·109, 1 β€ s β€ 2Β·109) β the initial number of seconds required to prepare one potion and the number of manapoints Anton can use.
The third line contains m integers ai (1 β€ ai < x) β the number of seconds it will take to prepare one potion if the i-th spell of the first type is used.
The fourth line contains m integers bi (1 β€ bi β€ 2Β·109) β the number of manapoints to use the i-th spell of the first type.
There are k integers ci (1 β€ ci β€ n) in the fifth line β the number of potions that will be immediately created if the i-th spell of the second type is used. It's guaranteed that ci are not decreasing, i.e. ci β€ cj if i < j.
The sixth line contains k integers di (1 β€ di β€ 2Β·109) β the number of manapoints required to use the i-th spell of the second type. It's guaranteed that di are not decreasing, i.e. di β€ dj if i < j.
Output
Print one integer β the minimum time one has to spent in order to prepare n potions.
Examples
Input
20 3 2
10 99
2 4 3
20 10 40
4 15
10 80
Output
20
Input
20 3 2
10 99
2 4 3
200 100 400
4 15
100 800
Output
200
Note
In the first sample, the optimum answer is to use the second spell of the first type that costs 10 manapoints. Thus, the preparation time of each potion changes to 4 seconds. Also, Anton should use the second spell of the second type to instantly prepare 15 potions spending 80 manapoints. The total number of manapoints used is 10 + 80 = 90, and the preparation time is 4Β·5 = 20 seconds (15 potions were prepared instantly, and the remaining 5 will take 4 seconds each).
In the second sample, Anton can't use any of the spells, so he just prepares 20 potions, spending 10 seconds on each of them and the answer is 20Β·10 = 200.
Submitted Solution:
```
from bisect import *
n,m,k=map(int,input().split())
x,s=map(int,input().split())
red=list(map(int,input().split()))
c1=list(map(int,input().split()))
c1.append(0)
red.append(x)
pot=list(map(int,input().split()))
c2=list(map(int,input().split()))
total=x*n
for i in range(len(red)):
if(c1[i]<=s):
left=s-c1[i]
q=bisect_left(c2,left)
if(len(c2)==q):
q-=1
elif(c2[q]!=left):
q-=1
if(q<0):
continue;
total=min((max(0,n-pot[q])*red[i]),total)
print(total)
```
|
instruction
| 0
| 18,184
| 2
| 36,368
|
No
|
output
| 1
| 18,184
| 2
| 36,369
|
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
Anton is playing a very interesting computer game, but now he is stuck at one of the levels. To pass to the next level he has to prepare n potions.
Anton has a special kettle, that can prepare one potions in x seconds. Also, he knows spells of two types that can faster the process of preparing potions.
1. Spells of this type speed up the preparation time of one potion. There are m spells of this type, the i-th of them costs bi manapoints and changes the preparation time of each potion to ai instead of x.
2. Spells of this type immediately prepare some number of potions. There are k such spells, the i-th of them costs di manapoints and instantly create ci potions.
Anton can use no more than one spell of the first type and no more than one spell of the second type, and the total number of manapoints spent should not exceed s. Consider that all spells are used instantly and right before Anton starts to prepare potions.
Anton wants to get to the next level as fast as possible, so he is interested in the minimum number of time he needs to spent in order to prepare at least n potions.
Input
The first line of the input contains three integers n, m, k (1 β€ n β€ 2Β·109, 1 β€ m, k β€ 2Β·105) β the number of potions, Anton has to make, the number of spells of the first type and the number of spells of the second type.
The second line of the input contains two integers x and s (2 β€ x β€ 2Β·109, 1 β€ s β€ 2Β·109) β the initial number of seconds required to prepare one potion and the number of manapoints Anton can use.
The third line contains m integers ai (1 β€ ai < x) β the number of seconds it will take to prepare one potion if the i-th spell of the first type is used.
The fourth line contains m integers bi (1 β€ bi β€ 2Β·109) β the number of manapoints to use the i-th spell of the first type.
There are k integers ci (1 β€ ci β€ n) in the fifth line β the number of potions that will be immediately created if the i-th spell of the second type is used. It's guaranteed that ci are not decreasing, i.e. ci β€ cj if i < j.
The sixth line contains k integers di (1 β€ di β€ 2Β·109) β the number of manapoints required to use the i-th spell of the second type. It's guaranteed that di are not decreasing, i.e. di β€ dj if i < j.
Output
Print one integer β the minimum time one has to spent in order to prepare n potions.
Examples
Input
20 3 2
10 99
2 4 3
20 10 40
4 15
10 80
Output
20
Input
20 3 2
10 99
2 4 3
200 100 400
4 15
100 800
Output
200
Note
In the first sample, the optimum answer is to use the second spell of the first type that costs 10 manapoints. Thus, the preparation time of each potion changes to 4 seconds. Also, Anton should use the second spell of the second type to instantly prepare 15 potions spending 80 manapoints. The total number of manapoints used is 10 + 80 = 90, and the preparation time is 4Β·5 = 20 seconds (15 potions were prepared instantly, and the remaining 5 will take 4 seconds each).
In the second sample, Anton can't use any of the spells, so he just prepares 20 potions, spending 10 seconds on each of them and the answer is 20Β·10 = 200.
Submitted Solution:
```
import bisect
n,m,k=map(int,input().split())
x,s=map(int,input().split())
a=list(map(int,input().split()))
b=list(map(int,input().split()))
c=list(map(int,input().split()))
d=list(map(int,input().split()))
ans=n*x
min_a=10**18
for i in range(m):
if b[i]<=s:
min_a=min(min_a,a[i])
ans=min(n*x,n*min_a)
for i in range(k):
if d[i]<=s:
ans=min(ans,n*x-x)
for i in range(m):
res=s-b[i]
if res>0:
idx=bisect.bisect_left(d,res)-1
if idx<0:
continue
ans=min(ans,a[i]*max(0,(n-c[idx])))
print(ans)
```
|
instruction
| 0
| 18,185
| 2
| 36,370
|
No
|
output
| 1
| 18,185
| 2
| 36,371
|
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
Anton is playing a very interesting computer game, but now he is stuck at one of the levels. To pass to the next level he has to prepare n potions.
Anton has a special kettle, that can prepare one potions in x seconds. Also, he knows spells of two types that can faster the process of preparing potions.
1. Spells of this type speed up the preparation time of one potion. There are m spells of this type, the i-th of them costs bi manapoints and changes the preparation time of each potion to ai instead of x.
2. Spells of this type immediately prepare some number of potions. There are k such spells, the i-th of them costs di manapoints and instantly create ci potions.
Anton can use no more than one spell of the first type and no more than one spell of the second type, and the total number of manapoints spent should not exceed s. Consider that all spells are used instantly and right before Anton starts to prepare potions.
Anton wants to get to the next level as fast as possible, so he is interested in the minimum number of time he needs to spent in order to prepare at least n potions.
Input
The first line of the input contains three integers n, m, k (1 β€ n β€ 2Β·109, 1 β€ m, k β€ 2Β·105) β the number of potions, Anton has to make, the number of spells of the first type and the number of spells of the second type.
The second line of the input contains two integers x and s (2 β€ x β€ 2Β·109, 1 β€ s β€ 2Β·109) β the initial number of seconds required to prepare one potion and the number of manapoints Anton can use.
The third line contains m integers ai (1 β€ ai < x) β the number of seconds it will take to prepare one potion if the i-th spell of the first type is used.
The fourth line contains m integers bi (1 β€ bi β€ 2Β·109) β the number of manapoints to use the i-th spell of the first type.
There are k integers ci (1 β€ ci β€ n) in the fifth line β the number of potions that will be immediately created if the i-th spell of the second type is used. It's guaranteed that ci are not decreasing, i.e. ci β€ cj if i < j.
The sixth line contains k integers di (1 β€ di β€ 2Β·109) β the number of manapoints required to use the i-th spell of the second type. It's guaranteed that di are not decreasing, i.e. di β€ dj if i < j.
Output
Print one integer β the minimum time one has to spent in order to prepare n potions.
Examples
Input
20 3 2
10 99
2 4 3
20 10 40
4 15
10 80
Output
20
Input
20 3 2
10 99
2 4 3
200 100 400
4 15
100 800
Output
200
Note
In the first sample, the optimum answer is to use the second spell of the first type that costs 10 manapoints. Thus, the preparation time of each potion changes to 4 seconds. Also, Anton should use the second spell of the second type to instantly prepare 15 potions spending 80 manapoints. The total number of manapoints used is 10 + 80 = 90, and the preparation time is 4Β·5 = 20 seconds (15 potions were prepared instantly, and the remaining 5 will take 4 seconds each).
In the second sample, Anton can't use any of the spells, so he just prepares 20 potions, spending 10 seconds on each of them and the answer is 20Β·10 = 200.
Submitted Solution:
```
n,m,k = map(int, input().split())
x,s = map(int, input().split())
a = list(map(int, input().split()))
b = list(map(int, input().split()))
c = list(map(int, input().split()))
d = list(map(int, input().split()))
ab = list(zip(a,b))
ab.sort(key=lambda x:-x[1])
ans = x*n
ind = 0
for ai,bi in ab:
while ind<k and d[ind]<=(s-bi): ind+=1
if ind==0: continue
tmp = (n-c[ind-1])*ai
ans = min(ans, tmp)
print(ans)
```
|
instruction
| 0
| 18,186
| 2
| 36,372
|
No
|
output
| 1
| 18,186
| 2
| 36,373
|
Provide tags and a correct Python 3 solution for this coding contest problem.
The year of 2012 is coming...
According to an ancient choradrican legend in this very year, in 2012, Diablo and his brothers Mephisto and Baal will escape from hell, and innumerable hordes of demons will enslave the human world. But seven brave heroes have already gathered on the top of a mountain Arreat to protect us mere mortals from the effect of this terrible evil.
The seven great heroes are: amazon Anka, barbarian Chapay, sorceress Cleo, druid Troll, necromancer Dracul, paladin Snowy and a professional hit girl Hexadecimal. Heroes already know how much experience will be given for each of the three megabosses: a for Mephisto, b for Diablo and c for Baal.
Here's the problem: heroes are as much as seven and megabosses are only three! Then our heroes decided to split into three teams, where each team will go to destroy their own megaboss. Each team member will receive a <image> of experience, rounded down, where x will be the amount of experience for the killed megaboss and y β the number of people in the team.
Heroes do not want to hurt each other's feelings, so they want to split into teams so that the difference between the hero who received the maximum number of experience and the hero who received the minimum number of experience were minimal. Since there can be several divisions into teams, then you need to find the one in which the total amount of liking in teams were maximum.
It is known that some heroes like others. But if hero p likes hero q, this does not mean that the hero q likes hero p. No hero likes himself.
The total amount of liking in teams is the amount of ordered pairs (p, q), such that heroes p and q are in the same group, and hero p likes hero q (but it is not important if hero q likes hero p). In case of heroes p and q likes each other and they are in the same group, this pair should be counted twice, as (p, q) and (q, p).
A team can consist even of a single hero, but it is important that every megaboss was destroyed. All heroes must be involved in the campaign against evil. None of the heroes can be in more than one team.
It is guaranteed that every hero is able to destroy any megaboss alone.
Input
The first line contains a single non-negative integer n (0 β€ n β€ 42) β amount of liking between the heroes. Next n lines describe liking in the form "p likes q", meaning that the hero p likes the hero q (p β q). Every liking is described in the input exactly once, no hero likes himself.
In the last line are given three integers a, b and c (1 β€ a, b, c β€ 2Β·109), separated by spaces: the experience for Mephisto, the experience for Diablo and experience for Baal.
In all the pretests, except for examples from the statement, the following condition is satisfied: a = b = c.
Output
Print two integers β the minimal difference in the experience between two heroes who will receive the maximum and minimum number of experience points, and the maximal total amount of liking in teams (the number of friendships between heroes that end up in one team).
When calculating the second answer, the team division should satisfy the difference-minimizing contraint. I.e. primary you should minimize the difference in the experience and secondary you should maximize the total amount of liking.
Examples
Input
3
Troll likes Dracul
Dracul likes Anka
Snowy likes Hexadecimal
210 200 180
Output
30 3
Input
2
Anka likes Chapay
Chapay likes Anka
10000 50 50
Output
1950 2
Note
A note to first example: it the first team should be Dracul, Troll and Anka, in the second one Hexadecimal and Snowy, and in the third Cleo ΠΈ Chapay.
|
instruction
| 0
| 18,203
| 2
| 36,406
|
Tags: brute force, implementation
Correct Solution:
```
from itertools import product, permutations, combinations
n = int(input())
names = {}
nex = 0
mama = 128
liking = [0]*mama
likes = [[0]*7 for _ in range(7)]
def getName(name):
global nex
if name in names:
return names[name]
names[name] = nex
nex += 1
return names[name]
for _ in range(n):
a, b, c = input().split()
likes[getName(a)][getName(c)] = 1
bosses = [int(x) for x in input().split()]
part = set()
part.add((0,0,0))
dipart = 10**10
for i in range(1, 4):
for j in range(i, 7):
k = 7-i-j
if k < j:
continue
for per in permutations(bosses):
aa = (per[0]//i,per[1]//j,per[2]//k)
difi = max(aa)-min(aa)
if difi < dipart:
dipart = difi
part = set()
part.add((i, j, k))
elif difi==dipart:
part.add((i,j,k))
# print(part, dipart)
# print(a,b,c)
for i, j in product(range(7), repeat=2):
if likes[i][j] == 0:
continue
mask = (1 << i) | (1 << j)
for k in range(mama):
if k & mask == mask:
liking[k] += 1
nums = list(range(7))
def tonum(ite):
r=0
for nu in ite:
r |= 1<<nu
return r
bea = 0
# print(part)
for a,b,c in part:
for pera in combinations(range(7), a):
# print(pera)
lefta = [x for x in nums if x not in pera]
for perb in combinations(lefta,b):
perc = [x for x in lefta if x not in perb]
# print(pera, perb, perc)
# print(tonum(pera), tonum(perb), tonum(perc))
susu = liking[tonum(pera)]+ liking[tonum(perb)]+ liking[tonum(perc)]
if susu> bea:
bea = susu
# print(liking[tonum(pera)],
# liking[tonum(perb)] , liking[tonum(perc)])
print(dipart,bea)
# for i in range(mama):
# print(i, liking[i])
```
|
output
| 1
| 18,203
| 2
| 36,407
|
Provide tags and a correct Python 3 solution for this coding contest problem.
The year of 2012 is coming...
According to an ancient choradrican legend in this very year, in 2012, Diablo and his brothers Mephisto and Baal will escape from hell, and innumerable hordes of demons will enslave the human world. But seven brave heroes have already gathered on the top of a mountain Arreat to protect us mere mortals from the effect of this terrible evil.
The seven great heroes are: amazon Anka, barbarian Chapay, sorceress Cleo, druid Troll, necromancer Dracul, paladin Snowy and a professional hit girl Hexadecimal. Heroes already know how much experience will be given for each of the three megabosses: a for Mephisto, b for Diablo and c for Baal.
Here's the problem: heroes are as much as seven and megabosses are only three! Then our heroes decided to split into three teams, where each team will go to destroy their own megaboss. Each team member will receive a <image> of experience, rounded down, where x will be the amount of experience for the killed megaboss and y β the number of people in the team.
Heroes do not want to hurt each other's feelings, so they want to split into teams so that the difference between the hero who received the maximum number of experience and the hero who received the minimum number of experience were minimal. Since there can be several divisions into teams, then you need to find the one in which the total amount of liking in teams were maximum.
It is known that some heroes like others. But if hero p likes hero q, this does not mean that the hero q likes hero p. No hero likes himself.
The total amount of liking in teams is the amount of ordered pairs (p, q), such that heroes p and q are in the same group, and hero p likes hero q (but it is not important if hero q likes hero p). In case of heroes p and q likes each other and they are in the same group, this pair should be counted twice, as (p, q) and (q, p).
A team can consist even of a single hero, but it is important that every megaboss was destroyed. All heroes must be involved in the campaign against evil. None of the heroes can be in more than one team.
It is guaranteed that every hero is able to destroy any megaboss alone.
Input
The first line contains a single non-negative integer n (0 β€ n β€ 42) β amount of liking between the heroes. Next n lines describe liking in the form "p likes q", meaning that the hero p likes the hero q (p β q). Every liking is described in the input exactly once, no hero likes himself.
In the last line are given three integers a, b and c (1 β€ a, b, c β€ 2Β·109), separated by spaces: the experience for Mephisto, the experience for Diablo and experience for Baal.
In all the pretests, except for examples from the statement, the following condition is satisfied: a = b = c.
Output
Print two integers β the minimal difference in the experience between two heroes who will receive the maximum and minimum number of experience points, and the maximal total amount of liking in teams (the number of friendships between heroes that end up in one team).
When calculating the second answer, the team division should satisfy the difference-minimizing contraint. I.e. primary you should minimize the difference in the experience and secondary you should maximize the total amount of liking.
Examples
Input
3
Troll likes Dracul
Dracul likes Anka
Snowy likes Hexadecimal
210 200 180
Output
30 3
Input
2
Anka likes Chapay
Chapay likes Anka
10000 50 50
Output
1950 2
Note
A note to first example: it the first team should be Dracul, Troll and Anka, in the second one Hexadecimal and Snowy, and in the third Cleo ΠΈ Chapay.
|
instruction
| 0
| 18,204
| 2
| 36,408
|
Tags: brute force, implementation
Correct Solution:
```
from itertools import combinations
def main():
heroes = ("Anka", "Chapay", "Cleo", "Troll", "Dracul", "Snowy", "Hexadecimal")
sympaty = [[False] * 7 for _ in range(7)]
for _ in range(int(input())):
a, _, b = input().split()
sympaty[heroes.index(a)][heroes.index(b)] = True
a, b, c = map(int, input().split())
tmp, res = [], []
for i in range(1, 6):
for j in range(1, 7 - i):
t = (int(a / i), int(b / j), int(c / (7 - i - j)))
tmp.append((max(t) - min(t), i, j))
delta = min(tmp)[0]
for i, j in ((i, j) for x, i, j in tmp if x == delta):
for aa in combinations(range(7), i):
rest = [x for x in range(7) if x not in aa]
for bb in combinations(rest, j):
res.append(sum(sum(sympaty[x][y] for x in xy for y in xy)
for xy in (aa, bb, [x for x in rest if x not in bb])))
print(delta, max(res))
main()
```
|
output
| 1
| 18,204
| 2
| 36,409
|
Provide tags and a correct Python 3 solution for this coding contest problem.
The year of 2012 is coming...
According to an ancient choradrican legend in this very year, in 2012, Diablo and his brothers Mephisto and Baal will escape from hell, and innumerable hordes of demons will enslave the human world. But seven brave heroes have already gathered on the top of a mountain Arreat to protect us mere mortals from the effect of this terrible evil.
The seven great heroes are: amazon Anka, barbarian Chapay, sorceress Cleo, druid Troll, necromancer Dracul, paladin Snowy and a professional hit girl Hexadecimal. Heroes already know how much experience will be given for each of the three megabosses: a for Mephisto, b for Diablo and c for Baal.
Here's the problem: heroes are as much as seven and megabosses are only three! Then our heroes decided to split into three teams, where each team will go to destroy their own megaboss. Each team member will receive a <image> of experience, rounded down, where x will be the amount of experience for the killed megaboss and y β the number of people in the team.
Heroes do not want to hurt each other's feelings, so they want to split into teams so that the difference between the hero who received the maximum number of experience and the hero who received the minimum number of experience were minimal. Since there can be several divisions into teams, then you need to find the one in which the total amount of liking in teams were maximum.
It is known that some heroes like others. But if hero p likes hero q, this does not mean that the hero q likes hero p. No hero likes himself.
The total amount of liking in teams is the amount of ordered pairs (p, q), such that heroes p and q are in the same group, and hero p likes hero q (but it is not important if hero q likes hero p). In case of heroes p and q likes each other and they are in the same group, this pair should be counted twice, as (p, q) and (q, p).
A team can consist even of a single hero, but it is important that every megaboss was destroyed. All heroes must be involved in the campaign against evil. None of the heroes can be in more than one team.
It is guaranteed that every hero is able to destroy any megaboss alone.
Input
The first line contains a single non-negative integer n (0 β€ n β€ 42) β amount of liking between the heroes. Next n lines describe liking in the form "p likes q", meaning that the hero p likes the hero q (p β q). Every liking is described in the input exactly once, no hero likes himself.
In the last line are given three integers a, b and c (1 β€ a, b, c β€ 2Β·109), separated by spaces: the experience for Mephisto, the experience for Diablo and experience for Baal.
In all the pretests, except for examples from the statement, the following condition is satisfied: a = b = c.
Output
Print two integers β the minimal difference in the experience between two heroes who will receive the maximum and minimum number of experience points, and the maximal total amount of liking in teams (the number of friendships between heroes that end up in one team).
When calculating the second answer, the team division should satisfy the difference-minimizing contraint. I.e. primary you should minimize the difference in the experience and secondary you should maximize the total amount of liking.
Examples
Input
3
Troll likes Dracul
Dracul likes Anka
Snowy likes Hexadecimal
210 200 180
Output
30 3
Input
2
Anka likes Chapay
Chapay likes Anka
10000 50 50
Output
1950 2
Note
A note to first example: it the first team should be Dracul, Troll and Anka, in the second one Hexadecimal and Snowy, and in the third Cleo ΠΈ Chapay.
|
instruction
| 0
| 18,205
| 2
| 36,410
|
Tags: brute force, implementation
Correct Solution:
```
from itertools import product, permutations, combinations
n = int(input())
names = {}
nex = 0
mama = 128
liking = [0]*mama
likes = [[0]*7 for _ in range(7)]
def getName(name):
global nex
if name in names:
return names[name]
names[name] = nex
nex += 1
return names[name]
for _ in range(n):
a, b, c = input().split()
likes[getName(a)][getName(c)] = 1
bosses = [int(x) for x in input().split()]
part = [(0,0,0)]
dipart = 10**10
for i in range(1, 4):
for j in range(i, 7):
k = 7-i-j
if k < j:
continue
for per in permutations(bosses):
aa = (per[0]//i,per[1]//j,per[2]//k)
difi = max(aa)-min(aa)
if difi < dipart:
dipart = difi
part = [(i,j,k)]
elif difi==dipart:
part.append((i,j,k))
# print(part, dipart)
# print(a,b,c)
for i, j in product(range(7), repeat=2):
if likes[i][j] == 0:
continue
mask = (1 << i) | (1 << j)
for k in range(mama):
if k & mask == mask:
liking[k] += 1
nums = list(range(7))
def tonum(ite):
r=0
for nu in ite:
r |= 1<<nu
return r
bea = 0
# print(part)
for a,b,c in part:
for pera in combinations(range(7), a):
# print(pera)
lefta = [x for x in nums if x not in pera]
for perb in combinations(lefta,b):
perc = [x for x in lefta if x not in perb]
# print(pera, perb, perc)
# print(tonum(pera), tonum(perb), tonum(perc))
susu = liking[tonum(pera)]+ liking[tonum(perb)]+ liking[tonum(perc)]
if susu> bea:
bea = susu
# print(liking[tonum(pera)],
# liking[tonum(perb)] , liking[tonum(perc)])
print(dipart,bea)
# for i in range(mama):
# print(i, liking[i])
```
|
output
| 1
| 18,205
| 2
| 36,411
|
Provide tags and a correct Python 3 solution for this coding contest problem.
The year of 2012 is coming...
According to an ancient choradrican legend in this very year, in 2012, Diablo and his brothers Mephisto and Baal will escape from hell, and innumerable hordes of demons will enslave the human world. But seven brave heroes have already gathered on the top of a mountain Arreat to protect us mere mortals from the effect of this terrible evil.
The seven great heroes are: amazon Anka, barbarian Chapay, sorceress Cleo, druid Troll, necromancer Dracul, paladin Snowy and a professional hit girl Hexadecimal. Heroes already know how much experience will be given for each of the three megabosses: a for Mephisto, b for Diablo and c for Baal.
Here's the problem: heroes are as much as seven and megabosses are only three! Then our heroes decided to split into three teams, where each team will go to destroy their own megaboss. Each team member will receive a <image> of experience, rounded down, where x will be the amount of experience for the killed megaboss and y β the number of people in the team.
Heroes do not want to hurt each other's feelings, so they want to split into teams so that the difference between the hero who received the maximum number of experience and the hero who received the minimum number of experience were minimal. Since there can be several divisions into teams, then you need to find the one in which the total amount of liking in teams were maximum.
It is known that some heroes like others. But if hero p likes hero q, this does not mean that the hero q likes hero p. No hero likes himself.
The total amount of liking in teams is the amount of ordered pairs (p, q), such that heroes p and q are in the same group, and hero p likes hero q (but it is not important if hero q likes hero p). In case of heroes p and q likes each other and they are in the same group, this pair should be counted twice, as (p, q) and (q, p).
A team can consist even of a single hero, but it is important that every megaboss was destroyed. All heroes must be involved in the campaign against evil. None of the heroes can be in more than one team.
It is guaranteed that every hero is able to destroy any megaboss alone.
Input
The first line contains a single non-negative integer n (0 β€ n β€ 42) β amount of liking between the heroes. Next n lines describe liking in the form "p likes q", meaning that the hero p likes the hero q (p β q). Every liking is described in the input exactly once, no hero likes himself.
In the last line are given three integers a, b and c (1 β€ a, b, c β€ 2Β·109), separated by spaces: the experience for Mephisto, the experience for Diablo and experience for Baal.
In all the pretests, except for examples from the statement, the following condition is satisfied: a = b = c.
Output
Print two integers β the minimal difference in the experience between two heroes who will receive the maximum and minimum number of experience points, and the maximal total amount of liking in teams (the number of friendships between heroes that end up in one team).
When calculating the second answer, the team division should satisfy the difference-minimizing contraint. I.e. primary you should minimize the difference in the experience and secondary you should maximize the total amount of liking.
Examples
Input
3
Troll likes Dracul
Dracul likes Anka
Snowy likes Hexadecimal
210 200 180
Output
30 3
Input
2
Anka likes Chapay
Chapay likes Anka
10000 50 50
Output
1950 2
Note
A note to first example: it the first team should be Dracul, Troll and Anka, in the second one Hexadecimal and Snowy, and in the third Cleo ΠΈ Chapay.
|
instruction
| 0
| 18,206
| 2
| 36,412
|
Tags: brute force, implementation
Correct Solution:
```
# 3
# Troll likes Dracul
# Dracul likes Anka
# Snowy likes Hexadecimal
# 210 200 180
# def set(heros):
# if len(heros) == 0:
# return [[]]
# elif len(heros) == 1:
# return [[heros[0]]]
# elif len(heros) == 2:
# return [[heros[0]], [heros[1]], heros]
# res = set(heros[1:])
# ans = []
# for i in res:
# ans.append(i)
# copyi = []
# for j in i:
# copyi.append(j)
# copyi.append(heros[0])
# ans.append(copyi)
# return ans
import itertools
def sets(heros,min_elem, max_elem):
ans = []
if max_elem > len(heros):
max_elem = len(heros)
if min_elem > len(heros):
return []
for i in range(min_elem,max_elem+1):
s = itertools.combinations(heros, i)
for ss in s:
ans.append(ss)
# ans.append(list(itertools.combinations(heros, i)))
return ans
def update(set1, set2,set3, x, y, a, b, c, pairs):
q = a//len(set1)
w = b//len(set2)
e = c//len(set3)
m = max(abs(q-w), abs(w-e), abs(e-q))
if m == x:
x = m
y1 = 0
for p in pairs:
if (p[0] in set1 and p[1] in set1) or (p[0] in set2 and p[1] in set2) or (p[0] in set3 and p[1] in set3):
y1 += 1
if y < y1:
y = y1
if m < x:
x = m
y = 0
for p in pairs:
if (p[0] in set1 and p[1] in set1) or (p[0] in set2 and p[1] in set2) or (p[0] in set3 and p[1] in set3):
y += 1
return x,y
def solve(n, pairs, a,b,c):
x,y = 100000000000000,0
heros = ['Anka', 'Chapay', 'Cleo', 'Troll', 'Dracul', 'Snowy', 'Hexadecimal']
# print(sets(heros,1,3))
for_set1 = sets(heros, 1,5)
for set1 in for_set1:
heros2 = []
for i in heros:
if i not in set1:
heros2.append(i)
# print("->", set1, heros2)
for_set2 = sets(heros2, 1, 7-len(set1))
for set2 in for_set2:
set3 = []
for i in heros2:
if i not in set2:
set3.append(i)
if len(set1) > 0 and len(set2) > 0 and len(set3) > 0:
x,y = update(set1,set2,set3,x,y, a, b, c, pairs)
# print(x,y, set1, set2, set3)
return x,y
n = int(input())
pairs = []
for i in range(n):
x,_,y = input().split()
pairs.append((x,y))
a,b,c = input().split()
a = int(a)
b = int(b)
c = int(c)
# n = 3
# pairs = [('Troll','Dracul'), ('Dracul', 'Anka'), ('Snowy', 'Hexadecimal')]
# a = 210
# b = 200
# c = 180
x,y = solve(a,pairs,a,b,c)
print(x,y)
```
|
output
| 1
| 18,206
| 2
| 36,413
|
Provide tags and a correct Python 3 solution for this coding contest problem.
The year of 2012 is coming...
According to an ancient choradrican legend in this very year, in 2012, Diablo and his brothers Mephisto and Baal will escape from hell, and innumerable hordes of demons will enslave the human world. But seven brave heroes have already gathered on the top of a mountain Arreat to protect us mere mortals from the effect of this terrible evil.
The seven great heroes are: amazon Anka, barbarian Chapay, sorceress Cleo, druid Troll, necromancer Dracul, paladin Snowy and a professional hit girl Hexadecimal. Heroes already know how much experience will be given for each of the three megabosses: a for Mephisto, b for Diablo and c for Baal.
Here's the problem: heroes are as much as seven and megabosses are only three! Then our heroes decided to split into three teams, where each team will go to destroy their own megaboss. Each team member will receive a <image> of experience, rounded down, where x will be the amount of experience for the killed megaboss and y β the number of people in the team.
Heroes do not want to hurt each other's feelings, so they want to split into teams so that the difference between the hero who received the maximum number of experience and the hero who received the minimum number of experience were minimal. Since there can be several divisions into teams, then you need to find the one in which the total amount of liking in teams were maximum.
It is known that some heroes like others. But if hero p likes hero q, this does not mean that the hero q likes hero p. No hero likes himself.
The total amount of liking in teams is the amount of ordered pairs (p, q), such that heroes p and q are in the same group, and hero p likes hero q (but it is not important if hero q likes hero p). In case of heroes p and q likes each other and they are in the same group, this pair should be counted twice, as (p, q) and (q, p).
A team can consist even of a single hero, but it is important that every megaboss was destroyed. All heroes must be involved in the campaign against evil. None of the heroes can be in more than one team.
It is guaranteed that every hero is able to destroy any megaboss alone.
Input
The first line contains a single non-negative integer n (0 β€ n β€ 42) β amount of liking between the heroes. Next n lines describe liking in the form "p likes q", meaning that the hero p likes the hero q (p β q). Every liking is described in the input exactly once, no hero likes himself.
In the last line are given three integers a, b and c (1 β€ a, b, c β€ 2Β·109), separated by spaces: the experience for Mephisto, the experience for Diablo and experience for Baal.
In all the pretests, except for examples from the statement, the following condition is satisfied: a = b = c.
Output
Print two integers β the minimal difference in the experience between two heroes who will receive the maximum and minimum number of experience points, and the maximal total amount of liking in teams (the number of friendships between heroes that end up in one team).
When calculating the second answer, the team division should satisfy the difference-minimizing contraint. I.e. primary you should minimize the difference in the experience and secondary you should maximize the total amount of liking.
Examples
Input
3
Troll likes Dracul
Dracul likes Anka
Snowy likes Hexadecimal
210 200 180
Output
30 3
Input
2
Anka likes Chapay
Chapay likes Anka
10000 50 50
Output
1950 2
Note
A note to first example: it the first team should be Dracul, Troll and Anka, in the second one Hexadecimal and Snowy, and in the third Cleo ΠΈ Chapay.
|
instruction
| 0
| 18,207
| 2
| 36,414
|
Tags: brute force, implementation
Correct Solution:
```
#!/usr/bin/env python3
import itertools
heroes = ["Anka", "Chapay", "Cleo", "Troll", "Dracul", "Snowy", "Hexadecimal"]
n = int(input())
edges = []
for i in range(n):
p,likes,q = input().split()
edges.append((heroes.index(p), heroes.index(q)))
boss_xp = list(map(int, input().split()))
min_difference = float('inf')
max_liking = float('-inf')
for assignment in itertools.product(range(3), repeat=7):
assignment_heroes = [[hero for (hero, boss) in enumerate(assignment) if (boss == i)] for i in range(3)]
if any(len(attackers) == 0 for attackers in assignment_heroes):
# Some bosses are not attacked at all
continue
xp_division = [xp // len(attackers) for (xp, attackers) in zip(boss_xp, assignment_heroes)]
difference = max(xp_division) - min(xp_division)
if (difference < min_difference):
min_difference = difference
max_liking = sum(len([(p,q) for (p,q) in edges if (p in attackers) and (q in attackers)]) for attackers in assignment_heroes)
elif (difference == min_difference):
liking = sum(len([(p,q) for (p,q) in edges if (p in attackers) and (q in attackers)]) for attackers in assignment_heroes)
max_liking = max(max_liking, liking)
print("%d %d" % (min_difference, max_liking))
```
|
output
| 1
| 18,207
| 2
| 36,415
|
Provide tags and a correct Python 3 solution for this coding contest problem.
The year of 2012 is coming...
According to an ancient choradrican legend in this very year, in 2012, Diablo and his brothers Mephisto and Baal will escape from hell, and innumerable hordes of demons will enslave the human world. But seven brave heroes have already gathered on the top of a mountain Arreat to protect us mere mortals from the effect of this terrible evil.
The seven great heroes are: amazon Anka, barbarian Chapay, sorceress Cleo, druid Troll, necromancer Dracul, paladin Snowy and a professional hit girl Hexadecimal. Heroes already know how much experience will be given for each of the three megabosses: a for Mephisto, b for Diablo and c for Baal.
Here's the problem: heroes are as much as seven and megabosses are only three! Then our heroes decided to split into three teams, where each team will go to destroy their own megaboss. Each team member will receive a <image> of experience, rounded down, where x will be the amount of experience for the killed megaboss and y β the number of people in the team.
Heroes do not want to hurt each other's feelings, so they want to split into teams so that the difference between the hero who received the maximum number of experience and the hero who received the minimum number of experience were minimal. Since there can be several divisions into teams, then you need to find the one in which the total amount of liking in teams were maximum.
It is known that some heroes like others. But if hero p likes hero q, this does not mean that the hero q likes hero p. No hero likes himself.
The total amount of liking in teams is the amount of ordered pairs (p, q), such that heroes p and q are in the same group, and hero p likes hero q (but it is not important if hero q likes hero p). In case of heroes p and q likes each other and they are in the same group, this pair should be counted twice, as (p, q) and (q, p).
A team can consist even of a single hero, but it is important that every megaboss was destroyed. All heroes must be involved in the campaign against evil. None of the heroes can be in more than one team.
It is guaranteed that every hero is able to destroy any megaboss alone.
Input
The first line contains a single non-negative integer n (0 β€ n β€ 42) β amount of liking between the heroes. Next n lines describe liking in the form "p likes q", meaning that the hero p likes the hero q (p β q). Every liking is described in the input exactly once, no hero likes himself.
In the last line are given three integers a, b and c (1 β€ a, b, c β€ 2Β·109), separated by spaces: the experience for Mephisto, the experience for Diablo and experience for Baal.
In all the pretests, except for examples from the statement, the following condition is satisfied: a = b = c.
Output
Print two integers β the minimal difference in the experience between two heroes who will receive the maximum and minimum number of experience points, and the maximal total amount of liking in teams (the number of friendships between heroes that end up in one team).
When calculating the second answer, the team division should satisfy the difference-minimizing contraint. I.e. primary you should minimize the difference in the experience and secondary you should maximize the total amount of liking.
Examples
Input
3
Troll likes Dracul
Dracul likes Anka
Snowy likes Hexadecimal
210 200 180
Output
30 3
Input
2
Anka likes Chapay
Chapay likes Anka
10000 50 50
Output
1950 2
Note
A note to first example: it the first team should be Dracul, Troll and Anka, in the second one Hexadecimal and Snowy, and in the third Cleo ΠΈ Chapay.
|
instruction
| 0
| 18,208
| 2
| 36,416
|
Tags: brute force, implementation
Correct Solution:
```
from itertools import *
p = {'An': 0, 'Ch': 1, 'Cl': 2, 'Tr': 3, 'Dr': 4, 'Sn': 5, 'He': 6}
def f():
u, l, v = input().split()
return p[u[:2]], p[v[:2]]
s = [f() for k in range(int(input()))]
a, b, c = map(int, input().split())
d = l = 9e9
for i in range(1, 6):
for j in range(1, 7 - i):
k = 7 - i - j
t = [a // i, b // j, c // k]
t = max(t) - min(t)
if t < d: d, l = t, 0
if t == d:
for q in set(permutations([0] * i + [1] * j + [2] * k)):
l = max(l, sum(q[u] == q[v] for u, v in s))
print(d, l)
```
|
output
| 1
| 18,208
| 2
| 36,417
|
Provide tags and a correct Python 3 solution for this coding contest problem.
The year of 2012 is coming...
According to an ancient choradrican legend in this very year, in 2012, Diablo and his brothers Mephisto and Baal will escape from hell, and innumerable hordes of demons will enslave the human world. But seven brave heroes have already gathered on the top of a mountain Arreat to protect us mere mortals from the effect of this terrible evil.
The seven great heroes are: amazon Anka, barbarian Chapay, sorceress Cleo, druid Troll, necromancer Dracul, paladin Snowy and a professional hit girl Hexadecimal. Heroes already know how much experience will be given for each of the three megabosses: a for Mephisto, b for Diablo and c for Baal.
Here's the problem: heroes are as much as seven and megabosses are only three! Then our heroes decided to split into three teams, where each team will go to destroy their own megaboss. Each team member will receive a <image> of experience, rounded down, where x will be the amount of experience for the killed megaboss and y β the number of people in the team.
Heroes do not want to hurt each other's feelings, so they want to split into teams so that the difference between the hero who received the maximum number of experience and the hero who received the minimum number of experience were minimal. Since there can be several divisions into teams, then you need to find the one in which the total amount of liking in teams were maximum.
It is known that some heroes like others. But if hero p likes hero q, this does not mean that the hero q likes hero p. No hero likes himself.
The total amount of liking in teams is the amount of ordered pairs (p, q), such that heroes p and q are in the same group, and hero p likes hero q (but it is not important if hero q likes hero p). In case of heroes p and q likes each other and they are in the same group, this pair should be counted twice, as (p, q) and (q, p).
A team can consist even of a single hero, but it is important that every megaboss was destroyed. All heroes must be involved in the campaign against evil. None of the heroes can be in more than one team.
It is guaranteed that every hero is able to destroy any megaboss alone.
Input
The first line contains a single non-negative integer n (0 β€ n β€ 42) β amount of liking between the heroes. Next n lines describe liking in the form "p likes q", meaning that the hero p likes the hero q (p β q). Every liking is described in the input exactly once, no hero likes himself.
In the last line are given three integers a, b and c (1 β€ a, b, c β€ 2Β·109), separated by spaces: the experience for Mephisto, the experience for Diablo and experience for Baal.
In all the pretests, except for examples from the statement, the following condition is satisfied: a = b = c.
Output
Print two integers β the minimal difference in the experience between two heroes who will receive the maximum and minimum number of experience points, and the maximal total amount of liking in teams (the number of friendships between heroes that end up in one team).
When calculating the second answer, the team division should satisfy the difference-minimizing contraint. I.e. primary you should minimize the difference in the experience and secondary you should maximize the total amount of liking.
Examples
Input
3
Troll likes Dracul
Dracul likes Anka
Snowy likes Hexadecimal
210 200 180
Output
30 3
Input
2
Anka likes Chapay
Chapay likes Anka
10000 50 50
Output
1950 2
Note
A note to first example: it the first team should be Dracul, Troll and Anka, in the second one Hexadecimal and Snowy, and in the third Cleo ΠΈ Chapay.
|
instruction
| 0
| 18,209
| 2
| 36,418
|
Tags: brute force, implementation
Correct Solution:
```
from itertools import combinations
def main():
heroes = ("Anka", "Chapay", "Cleo", "Troll", "Dracul", "Snowy", "Hexadecimal")
sympaty = [[False] * 7 for _ in range(7)]
for _ in range(int(input())):
a, _, b = input().split()
sympaty[heroes.index(a)][heroes.index(b)] = True
a, b, c = map(int, input().split())
tmp, res = [], []
for i in range(1, 6):
for j in range(1, 7 - i):
t = (int(a / i), int(b / j), int(c / (7 - i - j)))
tmp.append((max(t) - min(t), i, j))
delta = min(tmp)[0]
for i, j in ((i, j) for x, i, j in tmp if x == delta):
for aa in combinations(range(7), i):
rest = [x for x in range(7) if x not in aa]
for bb in combinations(rest, j):
res.append(sum(sum(sympaty[x][y] for x in xy for y in xy)
for xy in (aa, bb, [x for x in rest if x not in bb])))
print(delta, max(res))
if __name__ == '__main__':
main()
```
|
output
| 1
| 18,209
| 2
| 36,419
|
Provide tags and a correct Python 3 solution for this coding contest problem.
The year of 2012 is coming...
According to an ancient choradrican legend in this very year, in 2012, Diablo and his brothers Mephisto and Baal will escape from hell, and innumerable hordes of demons will enslave the human world. But seven brave heroes have already gathered on the top of a mountain Arreat to protect us mere mortals from the effect of this terrible evil.
The seven great heroes are: amazon Anka, barbarian Chapay, sorceress Cleo, druid Troll, necromancer Dracul, paladin Snowy and a professional hit girl Hexadecimal. Heroes already know how much experience will be given for each of the three megabosses: a for Mephisto, b for Diablo and c for Baal.
Here's the problem: heroes are as much as seven and megabosses are only three! Then our heroes decided to split into three teams, where each team will go to destroy their own megaboss. Each team member will receive a <image> of experience, rounded down, where x will be the amount of experience for the killed megaboss and y β the number of people in the team.
Heroes do not want to hurt each other's feelings, so they want to split into teams so that the difference between the hero who received the maximum number of experience and the hero who received the minimum number of experience were minimal. Since there can be several divisions into teams, then you need to find the one in which the total amount of liking in teams were maximum.
It is known that some heroes like others. But if hero p likes hero q, this does not mean that the hero q likes hero p. No hero likes himself.
The total amount of liking in teams is the amount of ordered pairs (p, q), such that heroes p and q are in the same group, and hero p likes hero q (but it is not important if hero q likes hero p). In case of heroes p and q likes each other and they are in the same group, this pair should be counted twice, as (p, q) and (q, p).
A team can consist even of a single hero, but it is important that every megaboss was destroyed. All heroes must be involved in the campaign against evil. None of the heroes can be in more than one team.
It is guaranteed that every hero is able to destroy any megaboss alone.
Input
The first line contains a single non-negative integer n (0 β€ n β€ 42) β amount of liking between the heroes. Next n lines describe liking in the form "p likes q", meaning that the hero p likes the hero q (p β q). Every liking is described in the input exactly once, no hero likes himself.
In the last line are given three integers a, b and c (1 β€ a, b, c β€ 2Β·109), separated by spaces: the experience for Mephisto, the experience for Diablo and experience for Baal.
In all the pretests, except for examples from the statement, the following condition is satisfied: a = b = c.
Output
Print two integers β the minimal difference in the experience between two heroes who will receive the maximum and minimum number of experience points, and the maximal total amount of liking in teams (the number of friendships between heroes that end up in one team).
When calculating the second answer, the team division should satisfy the difference-minimizing contraint. I.e. primary you should minimize the difference in the experience and secondary you should maximize the total amount of liking.
Examples
Input
3
Troll likes Dracul
Dracul likes Anka
Snowy likes Hexadecimal
210 200 180
Output
30 3
Input
2
Anka likes Chapay
Chapay likes Anka
10000 50 50
Output
1950 2
Note
A note to first example: it the first team should be Dracul, Troll and Anka, in the second one Hexadecimal and Snowy, and in the third Cleo ΠΈ Chapay.
|
instruction
| 0
| 18,210
| 2
| 36,420
|
Tags: brute force, implementation
Correct Solution:
```
R=range
S=str.split
I=input
L=S('Anka Chapay Cleo Troll Dracul Snowy Hexadecimal')
h={}
for i in R(7):h[L[i]]=i
d=[[]for i in R(9)]
for z in '0'*int(I()):a,_,b=S(I());d[h[a]]+=[h[b]]
a,b,c=map(int,S(I()))
o=[10**9,0]
def C(q,w,e,n):
if n==7:
if not(q and w and e):return
p=[a//len(q),b//len(w),c//(len(e))];p=max(p)-min(p);l=sum(k in g for g in(q,w,e)for h in g for k in d[h]);global o
if o[0]>p or o[0]==p and o[1]<l:o=p,l
else:C(q+[n],w,e,n+1);C(q,w+[n],e,n+1);C(q,w,e+[n],n+1)
C([],[],[],0)
print(o[0],o[1])
```
|
output
| 1
| 18,210
| 2
| 36,421
|
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
The year of 2012 is coming...
According to an ancient choradrican legend in this very year, in 2012, Diablo and his brothers Mephisto and Baal will escape from hell, and innumerable hordes of demons will enslave the human world. But seven brave heroes have already gathered on the top of a mountain Arreat to protect us mere mortals from the effect of this terrible evil.
The seven great heroes are: amazon Anka, barbarian Chapay, sorceress Cleo, druid Troll, necromancer Dracul, paladin Snowy and a professional hit girl Hexadecimal. Heroes already know how much experience will be given for each of the three megabosses: a for Mephisto, b for Diablo and c for Baal.
Here's the problem: heroes are as much as seven and megabosses are only three! Then our heroes decided to split into three teams, where each team will go to destroy their own megaboss. Each team member will receive a <image> of experience, rounded down, where x will be the amount of experience for the killed megaboss and y β the number of people in the team.
Heroes do not want to hurt each other's feelings, so they want to split into teams so that the difference between the hero who received the maximum number of experience and the hero who received the minimum number of experience were minimal. Since there can be several divisions into teams, then you need to find the one in which the total amount of liking in teams were maximum.
It is known that some heroes like others. But if hero p likes hero q, this does not mean that the hero q likes hero p. No hero likes himself.
The total amount of liking in teams is the amount of ordered pairs (p, q), such that heroes p and q are in the same group, and hero p likes hero q (but it is not important if hero q likes hero p). In case of heroes p and q likes each other and they are in the same group, this pair should be counted twice, as (p, q) and (q, p).
A team can consist even of a single hero, but it is important that every megaboss was destroyed. All heroes must be involved in the campaign against evil. None of the heroes can be in more than one team.
It is guaranteed that every hero is able to destroy any megaboss alone.
Input
The first line contains a single non-negative integer n (0 β€ n β€ 42) β amount of liking between the heroes. Next n lines describe liking in the form "p likes q", meaning that the hero p likes the hero q (p β q). Every liking is described in the input exactly once, no hero likes himself.
In the last line are given three integers a, b and c (1 β€ a, b, c β€ 2Β·109), separated by spaces: the experience for Mephisto, the experience for Diablo and experience for Baal.
In all the pretests, except for examples from the statement, the following condition is satisfied: a = b = c.
Output
Print two integers β the minimal difference in the experience between two heroes who will receive the maximum and minimum number of experience points, and the maximal total amount of liking in teams (the number of friendships between heroes that end up in one team).
When calculating the second answer, the team division should satisfy the difference-minimizing contraint. I.e. primary you should minimize the difference in the experience and secondary you should maximize the total amount of liking.
Examples
Input
3
Troll likes Dracul
Dracul likes Anka
Snowy likes Hexadecimal
210 200 180
Output
30 3
Input
2
Anka likes Chapay
Chapay likes Anka
10000 50 50
Output
1950 2
Note
A note to first example: it the first team should be Dracul, Troll and Anka, in the second one Hexadecimal and Snowy, and in the third Cleo ΠΈ Chapay.
Submitted Solution:
```
from itertools import *
p = {'An': 0, 'Ch': 1, 'Cl': 2, 'Tr': 3, 'Dr': 4, 'Sn': 5, 'He': 6}
def f():
u, l, v = input().split()
return p[u[:2]], p[v[:2]]
s = [f() for k in range(int(input()))]
a, b, c = map(int, input().split())
d = l = 9e9
for i in range(1, 6):
for j in range(1, 7 - i):
k = 7 - i - j
t = max((a - 1) // i, (b - 1) // j, (c - 1) // k) - min(a // i, b // j, c // k)
if t < d: d, l = t, 0
if t == d:
for q in set(permutations([0] * i + [1] * j + [2] * k)):
l = max(l, sum(q[u] == q[v] for u, v in s))
print(d + 1, l)
```
|
instruction
| 0
| 18,211
| 2
| 36,422
|
No
|
output
| 1
| 18,211
| 2
| 36,423
|
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
The year of 2012 is coming...
According to an ancient choradrican legend in this very year, in 2012, Diablo and his brothers Mephisto and Baal will escape from hell, and innumerable hordes of demons will enslave the human world. But seven brave heroes have already gathered on the top of a mountain Arreat to protect us mere mortals from the effect of this terrible evil.
The seven great heroes are: amazon Anka, barbarian Chapay, sorceress Cleo, druid Troll, necromancer Dracul, paladin Snowy and a professional hit girl Hexadecimal. Heroes already know how much experience will be given for each of the three megabosses: a for Mephisto, b for Diablo and c for Baal.
Here's the problem: heroes are as much as seven and megabosses are only three! Then our heroes decided to split into three teams, where each team will go to destroy their own megaboss. Each team member will receive a <image> of experience, rounded down, where x will be the amount of experience for the killed megaboss and y β the number of people in the team.
Heroes do not want to hurt each other's feelings, so they want to split into teams so that the difference between the hero who received the maximum number of experience and the hero who received the minimum number of experience were minimal. Since there can be several divisions into teams, then you need to find the one in which the total amount of liking in teams were maximum.
It is known that some heroes like others. But if hero p likes hero q, this does not mean that the hero q likes hero p. No hero likes himself.
The total amount of liking in teams is the amount of ordered pairs (p, q), such that heroes p and q are in the same group, and hero p likes hero q (but it is not important if hero q likes hero p). In case of heroes p and q likes each other and they are in the same group, this pair should be counted twice, as (p, q) and (q, p).
A team can consist even of a single hero, but it is important that every megaboss was destroyed. All heroes must be involved in the campaign against evil. None of the heroes can be in more than one team.
It is guaranteed that every hero is able to destroy any megaboss alone.
Input
The first line contains a single non-negative integer n (0 β€ n β€ 42) β amount of liking between the heroes. Next n lines describe liking in the form "p likes q", meaning that the hero p likes the hero q (p β q). Every liking is described in the input exactly once, no hero likes himself.
In the last line are given three integers a, b and c (1 β€ a, b, c β€ 2Β·109), separated by spaces: the experience for Mephisto, the experience for Diablo and experience for Baal.
In all the pretests, except for examples from the statement, the following condition is satisfied: a = b = c.
Output
Print two integers β the minimal difference in the experience between two heroes who will receive the maximum and minimum number of experience points, and the maximal total amount of liking in teams (the number of friendships between heroes that end up in one team).
When calculating the second answer, the team division should satisfy the difference-minimizing contraint. I.e. primary you should minimize the difference in the experience and secondary you should maximize the total amount of liking.
Examples
Input
3
Troll likes Dracul
Dracul likes Anka
Snowy likes Hexadecimal
210 200 180
Output
30 3
Input
2
Anka likes Chapay
Chapay likes Anka
10000 50 50
Output
1950 2
Note
A note to first example: it the first team should be Dracul, Troll and Anka, in the second one Hexadecimal and Snowy, and in the third Cleo ΠΈ Chapay.
Submitted Solution:
```
from itertools import *
p = {'An': 0, 'Ch': 1, 'Cl': 2, 'Tr': 3, 'Dr': 4, 'Sn': 5, 'He': 6}
def f():
u, l, v = input().split()
return p[u[:2]], p[v[:2]]
s = [f() for k in range(int(input()))]
a, b, c = map(int, input().split())
d = l = 9e9
for i in range(1, 6):
for j in range(1, 7 - i):
k = 7 - i - j
t = [a // i, b // j, c // k]
t = max(t) - min(t)
if t < d: d, l = t, 0
if t == d:
for q in set(permutations([0] * i + [1] * j + [2] * k)):
l = max(l, sum(q[u] == q[v] for u, v in s))
print(d + 1, l)
```
|
instruction
| 0
| 18,212
| 2
| 36,424
|
No
|
output
| 1
| 18,212
| 2
| 36,425
|
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
The year of 2012 is coming...
According to an ancient choradrican legend in this very year, in 2012, Diablo and his brothers Mephisto and Baal will escape from hell, and innumerable hordes of demons will enslave the human world. But seven brave heroes have already gathered on the top of a mountain Arreat to protect us mere mortals from the effect of this terrible evil.
The seven great heroes are: amazon Anka, barbarian Chapay, sorceress Cleo, druid Troll, necromancer Dracul, paladin Snowy and a professional hit girl Hexadecimal. Heroes already know how much experience will be given for each of the three megabosses: a for Mephisto, b for Diablo and c for Baal.
Here's the problem: heroes are as much as seven and megabosses are only three! Then our heroes decided to split into three teams, where each team will go to destroy their own megaboss. Each team member will receive a <image> of experience, rounded down, where x will be the amount of experience for the killed megaboss and y β the number of people in the team.
Heroes do not want to hurt each other's feelings, so they want to split into teams so that the difference between the hero who received the maximum number of experience and the hero who received the minimum number of experience were minimal. Since there can be several divisions into teams, then you need to find the one in which the total amount of liking in teams were maximum.
It is known that some heroes like others. But if hero p likes hero q, this does not mean that the hero q likes hero p. No hero likes himself.
The total amount of liking in teams is the amount of ordered pairs (p, q), such that heroes p and q are in the same group, and hero p likes hero q (but it is not important if hero q likes hero p). In case of heroes p and q likes each other and they are in the same group, this pair should be counted twice, as (p, q) and (q, p).
A team can consist even of a single hero, but it is important that every megaboss was destroyed. All heroes must be involved in the campaign against evil. None of the heroes can be in more than one team.
It is guaranteed that every hero is able to destroy any megaboss alone.
Input
The first line contains a single non-negative integer n (0 β€ n β€ 42) β amount of liking between the heroes. Next n lines describe liking in the form "p likes q", meaning that the hero p likes the hero q (p β q). Every liking is described in the input exactly once, no hero likes himself.
In the last line are given three integers a, b and c (1 β€ a, b, c β€ 2Β·109), separated by spaces: the experience for Mephisto, the experience for Diablo and experience for Baal.
In all the pretests, except for examples from the statement, the following condition is satisfied: a = b = c.
Output
Print two integers β the minimal difference in the experience between two heroes who will receive the maximum and minimum number of experience points, and the maximal total amount of liking in teams (the number of friendships between heroes that end up in one team).
When calculating the second answer, the team division should satisfy the difference-minimizing contraint. I.e. primary you should minimize the difference in the experience and secondary you should maximize the total amount of liking.
Examples
Input
3
Troll likes Dracul
Dracul likes Anka
Snowy likes Hexadecimal
210 200 180
Output
30 3
Input
2
Anka likes Chapay
Chapay likes Anka
10000 50 50
Output
1950 2
Note
A note to first example: it the first team should be Dracul, Troll and Anka, in the second one Hexadecimal and Snowy, and in the third Cleo ΠΈ Chapay.
Submitted Solution:
```
# 3
# Troll likes Dracul
# Dracul likes Anka
# Snowy likes Hexadecimal
# 210 200 180
# def set(heros):
# if len(heros) == 0:
# return [[]]
# elif len(heros) == 1:
# return [[heros[0]]]
# elif len(heros) == 2:
# return [[heros[0]], [heros[1]], heros]
# res = set(heros[1:])
# ans = []
# for i in res:
# ans.append(i)
# copyi = []
# for j in i:
# copyi.append(j)
# copyi.append(heros[0])
# ans.append(copyi)
# return ans
import itertools
def sets(heros,min_elem, max_elem):
ans = []
if max_elem > len(heros):
max_elem = len(heros)
if min_elem > len(heros):
return []
for i in range(min_elem,max_elem+1):
s = itertools.combinations(heros, i)
for ss in s:
ans.append(ss)
# ans.append(list(itertools.combinations(heros, i)))
return ans
def update(set1, set2,set3, x, y, a, b, c, pairs):
q = a//len(set1)
w = b//len(set2)
e = c//len(set3)
m = max(abs(q-w), abs(w-e), abs(e-q))
if m <= x:
x = m
y1 = 0
for p in pairs:
if (p[0] in set1 and p[1] in set1) or (p[0] in set2 and p[1] in set2) or (p[0] in set3 and p[1] in set3):
y1 += 1
if y < y1:
y = y1
return x,y
def solve(n, pairs, a,b,c):
x,y = 100000000000000,0
heros = ['Anka', 'Chapay', 'Cleo', 'Troll', 'Dracul', 'Snowy', 'Hexadecimal']
# print(sets(heros,1,3))
for_set1 = sets(heros, 1,5)
for set1 in for_set1:
heros2 = []
for i in heros:
if i not in set1:
heros2.append(i)
# print("->", set1, heros2)
for_set2 = sets(heros2, 1, 7-len(set1))
for set2 in for_set2:
set3 = []
for i in heros2:
if i not in set2:
set3.append(i)
if len(set1) > 0 and len(set2) > 0 and len(set3) > 0:
x,y = update(set1,set2,set3,x,y, a, b, c, pairs)
# print(x,y, set1, set2, set3)
return x,y
n = int(input())
pairs = []
for i in range(n):
x,_,y = input().split()
pairs.append((x,y))
a,b,c = input().split()
a = int(a)
b = int(b)
c = int(c)
# n = 3
# pairs = [('Troll','Dracul'), ('Dracul', 'Anka'), ('Snowy', 'Hexadecimal')]
# a = 210
# b = 200
# c = 180
x,y = solve(a,pairs,a,b,c)
print(x,y)
```
|
instruction
| 0
| 18,213
| 2
| 36,426
|
No
|
output
| 1
| 18,213
| 2
| 36,427
|
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
The year of 2012 is coming...
According to an ancient choradrican legend in this very year, in 2012, Diablo and his brothers Mephisto and Baal will escape from hell, and innumerable hordes of demons will enslave the human world. But seven brave heroes have already gathered on the top of a mountain Arreat to protect us mere mortals from the effect of this terrible evil.
The seven great heroes are: amazon Anka, barbarian Chapay, sorceress Cleo, druid Troll, necromancer Dracul, paladin Snowy and a professional hit girl Hexadecimal. Heroes already know how much experience will be given for each of the three megabosses: a for Mephisto, b for Diablo and c for Baal.
Here's the problem: heroes are as much as seven and megabosses are only three! Then our heroes decided to split into three teams, where each team will go to destroy their own megaboss. Each team member will receive a <image> of experience, rounded down, where x will be the amount of experience for the killed megaboss and y β the number of people in the team.
Heroes do not want to hurt each other's feelings, so they want to split into teams so that the difference between the hero who received the maximum number of experience and the hero who received the minimum number of experience were minimal. Since there can be several divisions into teams, then you need to find the one in which the total amount of liking in teams were maximum.
It is known that some heroes like others. But if hero p likes hero q, this does not mean that the hero q likes hero p. No hero likes himself.
The total amount of liking in teams is the amount of ordered pairs (p, q), such that heroes p and q are in the same group, and hero p likes hero q (but it is not important if hero q likes hero p). In case of heroes p and q likes each other and they are in the same group, this pair should be counted twice, as (p, q) and (q, p).
A team can consist even of a single hero, but it is important that every megaboss was destroyed. All heroes must be involved in the campaign against evil. None of the heroes can be in more than one team.
It is guaranteed that every hero is able to destroy any megaboss alone.
Input
The first line contains a single non-negative integer n (0 β€ n β€ 42) β amount of liking between the heroes. Next n lines describe liking in the form "p likes q", meaning that the hero p likes the hero q (p β q). Every liking is described in the input exactly once, no hero likes himself.
In the last line are given three integers a, b and c (1 β€ a, b, c β€ 2Β·109), separated by spaces: the experience for Mephisto, the experience for Diablo and experience for Baal.
In all the pretests, except for examples from the statement, the following condition is satisfied: a = b = c.
Output
Print two integers β the minimal difference in the experience between two heroes who will receive the maximum and minimum number of experience points, and the maximal total amount of liking in teams (the number of friendships between heroes that end up in one team).
When calculating the second answer, the team division should satisfy the difference-minimizing contraint. I.e. primary you should minimize the difference in the experience and secondary you should maximize the total amount of liking.
Examples
Input
3
Troll likes Dracul
Dracul likes Anka
Snowy likes Hexadecimal
210 200 180
Output
30 3
Input
2
Anka likes Chapay
Chapay likes Anka
10000 50 50
Output
1950 2
Note
A note to first example: it the first team should be Dracul, Troll and Anka, in the second one Hexadecimal and Snowy, and in the third Cleo ΠΈ Chapay.
Submitted Solution:
```
#!/usr/bin/env python3
import itertools
heroes = ["Anka", "Chapay", "Cleo", "Troll", "Dracul", "Snowy", "Hexadecimal"]
n = int(input())
edges = []
for i in range(n):
p,likes,q = input().split()
edges.append((heroes.index(p), heroes.index(q)))
boss_xp = list(map(int, input().split()))
min_difference = float('inf')
max_liking = float('-inf')
for assignment in itertools.product(range(3), repeat=7):
assignment_heroes = [[hero for (hero, boss) in enumerate(assignment) if (boss == i)] for i in range(3)]
if any(len(attackers) == 0 for attackers in assignment_heroes):
# Some bosses are not attacked at all
continue
xp_division = [xp / len(attackers) for (xp, attackers) in zip(boss_xp, assignment_heroes)]
difference = max(xp_division) - min(xp_division)
if (difference < min_difference):
min_difference = difference
max_liking = sum(len([(p,q) for (p,q) in edges if (p in attackers) and (q in attackers)]) for attackers in assignment_heroes)
elif (difference == min_difference):
liking = sum(len([(p,q) for (p,q) in edges if (p in attackers) and (q in attackers)]) for attackers in assignment_heroes)
max_liking = max(max_liking, liking)
print("%d %d" % (min_difference, max_liking))
```
|
instruction
| 0
| 18,214
| 2
| 36,428
|
No
|
output
| 1
| 18,214
| 2
| 36,429
|
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
Whoso in ignorance draws near to them and hears the Sirens' voice, he nevermore returns.
Homer, Odyssey
In the times of Jason and the Argonauts, it was well known that sirens use the sound of their songs to lure sailors into their demise. Yet only a few knew that every time sirens call a sailor by his name, his will weakens, making him more vulnerable.
For the purpose of this problem, both siren songs and names of the sailors will be represented as strings of lowercase English letters. The more times the sailor's name occurs as a contiguous substring of the song, the greater danger he is in.
Jason found out that sirens can sing one of the n+1 songs, which have the following structure: let s_i (0 β€ i β€ n) be the i-th song and t be a string of length n, then for every i < n: s_{i+1} = s_i t_i s_i. In other words i+1-st song is the concatenation of i-th song, i-th letter (0-indexed) of t and the i-th song.
Fortunately, he also knows s_0 and t. Jason wonders how many times a sailor's name is mentioned in a particular song. Answer q queries: given the sailor's name (w) and the index of a song (i) output the number of occurrences of w in s_i as a substring. As this number can be quite large, output its remainder modulo 10^9+7.
Input
In the first line of input there are two integers n, q ( 1 β€ n, q β€ 10^5) meaning that there are n+1 songs and q queries. In the next two lines strings s_0 and t follow (1 β€ |s_0| β€ 100, |t| = n).
Next q lines describe the queries; each one contains an integer k ( 0 β€ k β€ n), the index of the song sung by the sirens, and a non-empty string w, which is the name of a sailor. All strings in this problem consist only of lowercase English letters, and the sum of lengths of sailors' names does not exceed 10^6.
Output
Output q lines, i-th of them should contain the remainder modulo 10^9+7 of the number of occurrences of w in s_k.
Examples
Input
3 3
aa
bcd
2 aba
3 ca
3 aa
Output
2
2
8
Input
4 5
aba
bbac
1 a
3 baca
3 ab
2 bab
4 aba
Output
4
0
14
6
28
Note
In the first example songs of the sirens are as follows:
* Song 0: aa
* Song 1: aabaa
* Song 2: aabaacaabaa
* Song 3: aabaacaabaadaabaacaabaa
Submitted Solution:
```
z=input()
n,Q=z.split()
n,Q=int(n),int(Q)
s=[]
s.append(input())
t=input()
print(s,t)
i=0
for q in range(Q):
z=input()
count=0
k,w=z.split()
k=int(k)
while i<k:
s.append(s[i]+t[i]+s[i])
i+=1
x=s[i]
for y in range(len(x)):
if y+len(w)>len(x):
break
if x[y:y+len(w)]==w:
count+=1
print(count)
```
|
instruction
| 0
| 18,752
| 2
| 37,504
|
No
|
output
| 1
| 18,752
| 2
| 37,505
|
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.