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
|
|---|---|---|---|---|---|
Provide tags and a correct Python 3 solution for this coding contest problem.
Kuriyama Mirai has killed many monsters and got many (namely n) stones. She numbers the stones from 1 to n. The cost of the i-th stone is vi. Kuriyama Mirai wants to know something about these stones so she will ask you two kinds of questions:
1. She will tell you two numbers, l and r (1 ≤ l ≤ r ≤ n), and you should tell her <image>.
2. Let ui be the cost of the i-th cheapest stone (the cost that will be on the i-th place if we arrange all the stone costs in non-decreasing order). This time she will tell you two numbers, l and r (1 ≤ l ≤ r ≤ n), and you should tell her <image>.
For every question you should give the correct answer, or Kuriyama Mirai will say "fuyukai desu" and then become unhappy.
Input
The first line contains an integer n (1 ≤ n ≤ 105). The second line contains n integers: v1, v2, ..., vn (1 ≤ vi ≤ 109) — costs of the stones.
The third line contains an integer m (1 ≤ m ≤ 105) — the number of Kuriyama Mirai's questions. Then follow m lines, each line contains three integers type, l and r (1 ≤ l ≤ r ≤ n; 1 ≤ type ≤ 2), describing a question. If type equal to 1, then you should output the answer for the first question, else you should output the answer for the second one.
Output
Print m lines. Each line must contain an integer — the answer to Kuriyama Mirai's question. Print the answers to the questions in the order of input.
Examples
Input
6
6 4 2 7 2 7
3
2 3 6
1 3 4
1 1 6
Output
24
9
28
Input
4
5 5 2 3
10
1 2 4
2 1 4
1 1 1
2 1 4
2 1 2
1 1 1
1 3 3
1 1 3
1 4 4
1 2 2
Output
10
15
5
15
5
5
2
12
3
5
Note
Please note that the answers to the questions may overflow 32-bit integer type.
|
instruction
| 0
| 2,827
| 2
| 5,654
|
Tags: dp, implementation, sortings
Correct Solution:
```
# Input
n = int(input())
v = list(map(int, input().split()))
# Sorting V
sorted_v = sorted(v)
# Prefix Sum Arrays
prefix_v = [0]
sorted_prefix = [0]
sum_v = 0
sums = 0
# Prefix For Unsorted Values
for x in v:
sums += x
prefix_v.append(sums)
# Prefix For Sorted Values
for x in sorted_v:
sum_v += x
sorted_prefix.append(sum_v)
for _ in range(int(input())):
question = list(map(int, input().split()))
q = question[0]
# For Question 2
if q == 2:
point1 = question[1] - 1
point2 = question[2]
sums = 0
print(sorted_prefix[point2] - sorted_prefix[point1])
# For Question 1
else:
point1 = question[1] - 1
point2 = question[2]
print(prefix_v[point2] - prefix_v[point1])
```
|
output
| 1
| 2,827
| 2
| 5,655
|
Provide tags and a correct Python 3 solution for this coding contest problem.
Kuriyama Mirai has killed many monsters and got many (namely n) stones. She numbers the stones from 1 to n. The cost of the i-th stone is vi. Kuriyama Mirai wants to know something about these stones so she will ask you two kinds of questions:
1. She will tell you two numbers, l and r (1 ≤ l ≤ r ≤ n), and you should tell her <image>.
2. Let ui be the cost of the i-th cheapest stone (the cost that will be on the i-th place if we arrange all the stone costs in non-decreasing order). This time she will tell you two numbers, l and r (1 ≤ l ≤ r ≤ n), and you should tell her <image>.
For every question you should give the correct answer, or Kuriyama Mirai will say "fuyukai desu" and then become unhappy.
Input
The first line contains an integer n (1 ≤ n ≤ 105). The second line contains n integers: v1, v2, ..., vn (1 ≤ vi ≤ 109) — costs of the stones.
The third line contains an integer m (1 ≤ m ≤ 105) — the number of Kuriyama Mirai's questions. Then follow m lines, each line contains three integers type, l and r (1 ≤ l ≤ r ≤ n; 1 ≤ type ≤ 2), describing a question. If type equal to 1, then you should output the answer for the first question, else you should output the answer for the second one.
Output
Print m lines. Each line must contain an integer — the answer to Kuriyama Mirai's question. Print the answers to the questions in the order of input.
Examples
Input
6
6 4 2 7 2 7
3
2 3 6
1 3 4
1 1 6
Output
24
9
28
Input
4
5 5 2 3
10
1 2 4
2 1 4
1 1 1
2 1 4
2 1 2
1 1 1
1 3 3
1 1 3
1 4 4
1 2 2
Output
10
15
5
15
5
5
2
12
3
5
Note
Please note that the answers to the questions may overflow 32-bit integer type.
|
instruction
| 0
| 2,828
| 2
| 5,656
|
Tags: dp, implementation, sortings
Correct Solution:
```
import sys
input = sys.stdin.readline
I = lambda:map(int,input().split())
n = int(input())
v = [0] + list(I())
u = sorted(v)
for i in range(1,n + 1):
v[i] += v[i-1]
u[i] += u[i-1]
for _ in range(int(input())):
t,l,r = I()
if t == 1:
print(v[r] - v[l-1])
else:
print(u[r] - u[l-1])
```
|
output
| 1
| 2,828
| 2
| 5,657
|
Provide tags and a correct Python 3 solution for this coding contest problem.
Kuriyama Mirai has killed many monsters and got many (namely n) stones. She numbers the stones from 1 to n. The cost of the i-th stone is vi. Kuriyama Mirai wants to know something about these stones so she will ask you two kinds of questions:
1. She will tell you two numbers, l and r (1 ≤ l ≤ r ≤ n), and you should tell her <image>.
2. Let ui be the cost of the i-th cheapest stone (the cost that will be on the i-th place if we arrange all the stone costs in non-decreasing order). This time she will tell you two numbers, l and r (1 ≤ l ≤ r ≤ n), and you should tell her <image>.
For every question you should give the correct answer, or Kuriyama Mirai will say "fuyukai desu" and then become unhappy.
Input
The first line contains an integer n (1 ≤ n ≤ 105). The second line contains n integers: v1, v2, ..., vn (1 ≤ vi ≤ 109) — costs of the stones.
The third line contains an integer m (1 ≤ m ≤ 105) — the number of Kuriyama Mirai's questions. Then follow m lines, each line contains three integers type, l and r (1 ≤ l ≤ r ≤ n; 1 ≤ type ≤ 2), describing a question. If type equal to 1, then you should output the answer for the first question, else you should output the answer for the second one.
Output
Print m lines. Each line must contain an integer — the answer to Kuriyama Mirai's question. Print the answers to the questions in the order of input.
Examples
Input
6
6 4 2 7 2 7
3
2 3 6
1 3 4
1 1 6
Output
24
9
28
Input
4
5 5 2 3
10
1 2 4
2 1 4
1 1 1
2 1 4
2 1 2
1 1 1
1 3 3
1 1 3
1 4 4
1 2 2
Output
10
15
5
15
5
5
2
12
3
5
Note
Please note that the answers to the questions may overflow 32-bit integer type.
|
instruction
| 0
| 2,829
| 2
| 5,658
|
Tags: dp, implementation, sortings
Correct Solution:
```
from itertools import accumulate
n = int(input())
v = [0]+list(map(int,input().split()))
ls = sorted(v)
v = list(accumulate(v))
ls = list(accumulate(ls))
m = int(input())
for i in range(m):
s = 0
t,l,r = map(int,input().split())
if t==1:
print(v[r]-v[l-1])
elif t==2:
print(ls[r]-ls[l-1])
```
|
output
| 1
| 2,829
| 2
| 5,659
|
Provide tags and a correct Python 3 solution for this coding contest problem.
Kuriyama Mirai has killed many monsters and got many (namely n) stones. She numbers the stones from 1 to n. The cost of the i-th stone is vi. Kuriyama Mirai wants to know something about these stones so she will ask you two kinds of questions:
1. She will tell you two numbers, l and r (1 ≤ l ≤ r ≤ n), and you should tell her <image>.
2. Let ui be the cost of the i-th cheapest stone (the cost that will be on the i-th place if we arrange all the stone costs in non-decreasing order). This time she will tell you two numbers, l and r (1 ≤ l ≤ r ≤ n), and you should tell her <image>.
For every question you should give the correct answer, or Kuriyama Mirai will say "fuyukai desu" and then become unhappy.
Input
The first line contains an integer n (1 ≤ n ≤ 105). The second line contains n integers: v1, v2, ..., vn (1 ≤ vi ≤ 109) — costs of the stones.
The third line contains an integer m (1 ≤ m ≤ 105) — the number of Kuriyama Mirai's questions. Then follow m lines, each line contains three integers type, l and r (1 ≤ l ≤ r ≤ n; 1 ≤ type ≤ 2), describing a question. If type equal to 1, then you should output the answer for the first question, else you should output the answer for the second one.
Output
Print m lines. Each line must contain an integer — the answer to Kuriyama Mirai's question. Print the answers to the questions in the order of input.
Examples
Input
6
6 4 2 7 2 7
3
2 3 6
1 3 4
1 1 6
Output
24
9
28
Input
4
5 5 2 3
10
1 2 4
2 1 4
1 1 1
2 1 4
2 1 2
1 1 1
1 3 3
1 1 3
1 4 4
1 2 2
Output
10
15
5
15
5
5
2
12
3
5
Note
Please note that the answers to the questions may overflow 32-bit integer type.
|
instruction
| 0
| 2,830
| 2
| 5,660
|
Tags: dp, implementation, sortings
Correct Solution:
```
n = int(input())
v = list(map(int, input().split(' ')))
u = sorted(v)
s_v = [0]
s_u = [0]
for i in range(1, n + 1):
s_v.append(s_v[i - 1] + v[i - 1])
s_u.append(s_u[i - 1] + u[i - 1])
ans = []
for _ in range(int(input())):
t, l, r = map(int, input().split(' '))
if t == 1:
tt = s_v[r] - s_v[l - 1]
else:
tt = s_u[r] - s_u[l - 1]
ans.append(str(tt))
print('\n'.join(ans))
```
|
output
| 1
| 2,830
| 2
| 5,661
|
Provide tags and a correct Python 3 solution for this coding contest problem.
Kuriyama Mirai has killed many monsters and got many (namely n) stones. She numbers the stones from 1 to n. The cost of the i-th stone is vi. Kuriyama Mirai wants to know something about these stones so she will ask you two kinds of questions:
1. She will tell you two numbers, l and r (1 ≤ l ≤ r ≤ n), and you should tell her <image>.
2. Let ui be the cost of the i-th cheapest stone (the cost that will be on the i-th place if we arrange all the stone costs in non-decreasing order). This time she will tell you two numbers, l and r (1 ≤ l ≤ r ≤ n), and you should tell her <image>.
For every question you should give the correct answer, or Kuriyama Mirai will say "fuyukai desu" and then become unhappy.
Input
The first line contains an integer n (1 ≤ n ≤ 105). The second line contains n integers: v1, v2, ..., vn (1 ≤ vi ≤ 109) — costs of the stones.
The third line contains an integer m (1 ≤ m ≤ 105) — the number of Kuriyama Mirai's questions. Then follow m lines, each line contains three integers type, l and r (1 ≤ l ≤ r ≤ n; 1 ≤ type ≤ 2), describing a question. If type equal to 1, then you should output the answer for the first question, else you should output the answer for the second one.
Output
Print m lines. Each line must contain an integer — the answer to Kuriyama Mirai's question. Print the answers to the questions in the order of input.
Examples
Input
6
6 4 2 7 2 7
3
2 3 6
1 3 4
1 1 6
Output
24
9
28
Input
4
5 5 2 3
10
1 2 4
2 1 4
1 1 1
2 1 4
2 1 2
1 1 1
1 3 3
1 1 3
1 4 4
1 2 2
Output
10
15
5
15
5
5
2
12
3
5
Note
Please note that the answers to the questions may overflow 32-bit integer type.
|
instruction
| 0
| 2,831
| 2
| 5,662
|
Tags: dp, implementation, sortings
Correct Solution:
```
n=int(input())
arr=list(map(int, input().split()))
arranged=sorted(arr)
sum1=sum(arr)
sum2=sum(arranged)
prefix_sum1=[arr[0]]
for i in range(1,n):
prefix_sum1.append(arr[i]+prefix_sum1[-1])
suffix_sum1=[arr[-1]]
for i in range(n-2,-1,-1):
suffix_sum1.append(arr[i]+suffix_sum1[-1])
prefix_sum2=[arranged[0]]
for i in range(1,n):
prefix_sum2.append(arranged[i]+prefix_sum2[-1])
suffix_sum2=[arranged[-1]]
for i in range(n-2,-1,-1):
suffix_sum2.append(arranged[i]+suffix_sum2[-1])
m=int(input())
for i in range(m):
type, l, r = map(int, input().split())
if type==1:
if r-l+1==n:
print(sum1)
elif l==1:
print(sum1-(suffix_sum1[n-r-1]))
elif r==n:
print(sum1-(prefix_sum1[l-2]))
elif r==n:
print(sum1-(prefix_sum1[l-2]+suffix_sum1[n-r-1]))
else:
print(sum1-(prefix_sum1[l-2]+suffix_sum1[n-r-1]))
else:
if r-l+1==n:
print(sum2)
elif l==1:
print(sum2-(suffix_sum2[n-r-1]))
elif r==n:
print(sum2-(prefix_sum2[l-2]))
elif r==n:
print(sum2-(prefix_sum2[l-2]+suffix_sum2[n-r-1]))
else:
print(sum2-(prefix_sum2[l-2]+suffix_sum2[n-r-1]))
```
|
output
| 1
| 2,831
| 2
| 5,663
|
Provide tags and a correct Python 3 solution for this coding contest problem.
Kuriyama Mirai has killed many monsters and got many (namely n) stones. She numbers the stones from 1 to n. The cost of the i-th stone is vi. Kuriyama Mirai wants to know something about these stones so she will ask you two kinds of questions:
1. She will tell you two numbers, l and r (1 ≤ l ≤ r ≤ n), and you should tell her <image>.
2. Let ui be the cost of the i-th cheapest stone (the cost that will be on the i-th place if we arrange all the stone costs in non-decreasing order). This time she will tell you two numbers, l and r (1 ≤ l ≤ r ≤ n), and you should tell her <image>.
For every question you should give the correct answer, or Kuriyama Mirai will say "fuyukai desu" and then become unhappy.
Input
The first line contains an integer n (1 ≤ n ≤ 105). The second line contains n integers: v1, v2, ..., vn (1 ≤ vi ≤ 109) — costs of the stones.
The third line contains an integer m (1 ≤ m ≤ 105) — the number of Kuriyama Mirai's questions. Then follow m lines, each line contains three integers type, l and r (1 ≤ l ≤ r ≤ n; 1 ≤ type ≤ 2), describing a question. If type equal to 1, then you should output the answer for the first question, else you should output the answer for the second one.
Output
Print m lines. Each line must contain an integer — the answer to Kuriyama Mirai's question. Print the answers to the questions in the order of input.
Examples
Input
6
6 4 2 7 2 7
3
2 3 6
1 3 4
1 1 6
Output
24
9
28
Input
4
5 5 2 3
10
1 2 4
2 1 4
1 1 1
2 1 4
2 1 2
1 1 1
1 3 3
1 1 3
1 4 4
1 2 2
Output
10
15
5
15
5
5
2
12
3
5
Note
Please note that the answers to the questions may overflow 32-bit integer type.
|
instruction
| 0
| 2,832
| 2
| 5,664
|
Tags: dp, implementation, sortings
Correct Solution:
```
n=int(input())
v=list(map(int,input().split()))
l1=[0]*(n+1)
l2=[0]*(n+1)
l1[1]=v[0]
for i in range(2,n+1):
l1[i]=l1[i-1]+v[i-1]
v.sort()
l2[1]=v[0]
for i in range(2,n+1):
l2[i]=l2[i-1]+v[i-1]
m=int(input())
for i in range(m):
t,l,r=map(int,input().split())
if t==1:
print(l1[r]-l1[l-1])
else:
print(l2[r]-l2[l-1])
```
|
output
| 1
| 2,832
| 2
| 5,665
|
Provide tags and a correct Python 3 solution for this coding contest problem.
Kuriyama Mirai has killed many monsters and got many (namely n) stones. She numbers the stones from 1 to n. The cost of the i-th stone is vi. Kuriyama Mirai wants to know something about these stones so she will ask you two kinds of questions:
1. She will tell you two numbers, l and r (1 ≤ l ≤ r ≤ n), and you should tell her <image>.
2. Let ui be the cost of the i-th cheapest stone (the cost that will be on the i-th place if we arrange all the stone costs in non-decreasing order). This time she will tell you two numbers, l and r (1 ≤ l ≤ r ≤ n), and you should tell her <image>.
For every question you should give the correct answer, or Kuriyama Mirai will say "fuyukai desu" and then become unhappy.
Input
The first line contains an integer n (1 ≤ n ≤ 105). The second line contains n integers: v1, v2, ..., vn (1 ≤ vi ≤ 109) — costs of the stones.
The third line contains an integer m (1 ≤ m ≤ 105) — the number of Kuriyama Mirai's questions. Then follow m lines, each line contains three integers type, l and r (1 ≤ l ≤ r ≤ n; 1 ≤ type ≤ 2), describing a question. If type equal to 1, then you should output the answer for the first question, else you should output the answer for the second one.
Output
Print m lines. Each line must contain an integer — the answer to Kuriyama Mirai's question. Print the answers to the questions in the order of input.
Examples
Input
6
6 4 2 7 2 7
3
2 3 6
1 3 4
1 1 6
Output
24
9
28
Input
4
5 5 2 3
10
1 2 4
2 1 4
1 1 1
2 1 4
2 1 2
1 1 1
1 3 3
1 1 3
1 4 4
1 2 2
Output
10
15
5
15
5
5
2
12
3
5
Note
Please note that the answers to the questions may overflow 32-bit integer type.
|
instruction
| 0
| 2,833
| 2
| 5,666
|
Tags: dp, implementation, sortings
Correct Solution:
```
n=int(input())
v=list(map(int,input().split()))
u=[]
for i in range(n):
u.append(v[i])
u.sort()
for i in range(1,n):
v[i]+=v[i-1]
for i in range(1,n):
u[i]+=u[i-1]
c=[0]
d=[0]
for i in range(n):
c.append(v[i])
d.append(u[i])
q=int(input())
for i in range(q):
a,l,r=map(int,input().split())
if a==1:
print(c[r]-c[l-1])
else:
print(d[r]-d[l-1])
```
|
output
| 1
| 2,833
| 2
| 5,667
|
Provide tags and a correct Python 3 solution for this coding contest problem.
Kuriyama Mirai has killed many monsters and got many (namely n) stones. She numbers the stones from 1 to n. The cost of the i-th stone is vi. Kuriyama Mirai wants to know something about these stones so she will ask you two kinds of questions:
1. She will tell you two numbers, l and r (1 ≤ l ≤ r ≤ n), and you should tell her <image>.
2. Let ui be the cost of the i-th cheapest stone (the cost that will be on the i-th place if we arrange all the stone costs in non-decreasing order). This time she will tell you two numbers, l and r (1 ≤ l ≤ r ≤ n), and you should tell her <image>.
For every question you should give the correct answer, or Kuriyama Mirai will say "fuyukai desu" and then become unhappy.
Input
The first line contains an integer n (1 ≤ n ≤ 105). The second line contains n integers: v1, v2, ..., vn (1 ≤ vi ≤ 109) — costs of the stones.
The third line contains an integer m (1 ≤ m ≤ 105) — the number of Kuriyama Mirai's questions. Then follow m lines, each line contains three integers type, l and r (1 ≤ l ≤ r ≤ n; 1 ≤ type ≤ 2), describing a question. If type equal to 1, then you should output the answer for the first question, else you should output the answer for the second one.
Output
Print m lines. Each line must contain an integer — the answer to Kuriyama Mirai's question. Print the answers to the questions in the order of input.
Examples
Input
6
6 4 2 7 2 7
3
2 3 6
1 3 4
1 1 6
Output
24
9
28
Input
4
5 5 2 3
10
1 2 4
2 1 4
1 1 1
2 1 4
2 1 2
1 1 1
1 3 3
1 1 3
1 4 4
1 2 2
Output
10
15
5
15
5
5
2
12
3
5
Note
Please note that the answers to the questions may overflow 32-bit integer type.
|
instruction
| 0
| 2,834
| 2
| 5,668
|
Tags: dp, implementation, sortings
Correct Solution:
```
# Kuriyama mari stones
from typing import List
class Solution:
@classmethod
def sum_array(cls, numbers: List[int]) -> List[int]:
sum_numbers = [0]
for index, num in enumerate(numbers):
prev = sum_numbers[index]
next = numbers[index]
sum_numbers.append(prev + next)
return sum_numbers
@classmethod
def sorted_sum_array(cls, numbers: List[int]) -> List[int]:
sorted_numbers = sorted(numbers)
sorted_sum_numbers = cls.sum_array(sorted_numbers)
return sorted_sum_numbers
@classmethod
def query(
cls,
sum_numbers: List[int],
sorted_sum_numbers: List[int],
qtype: int,
low: int,
high: int,
) -> int:
if qtype == 1:
return sum_numbers[high] - sum_numbers[low - 1]
else:
return sorted_sum_numbers[high] - sorted_sum_numbers[low - 1]
if __name__ == "__main__":
num = int(input())
numbers = list(map(lambda x: int(x), input().split()))
sum_numbers = Solution.sum_array(numbers)
sorted_sum_numbers = Solution.sorted_sum_array(numbers)
num_questions = int(input())
for i in range(num_questions):
[qtype, low, high] = list(map(lambda x: int(x), input().split()))
answer = Solution.query(sum_numbers, sorted_sum_numbers, qtype, low, high)
print(answer)
```
|
output
| 1
| 2,834
| 2
| 5,669
|
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
Kuriyama Mirai has killed many monsters and got many (namely n) stones. She numbers the stones from 1 to n. The cost of the i-th stone is vi. Kuriyama Mirai wants to know something about these stones so she will ask you two kinds of questions:
1. She will tell you two numbers, l and r (1 ≤ l ≤ r ≤ n), and you should tell her <image>.
2. Let ui be the cost of the i-th cheapest stone (the cost that will be on the i-th place if we arrange all the stone costs in non-decreasing order). This time she will tell you two numbers, l and r (1 ≤ l ≤ r ≤ n), and you should tell her <image>.
For every question you should give the correct answer, or Kuriyama Mirai will say "fuyukai desu" and then become unhappy.
Input
The first line contains an integer n (1 ≤ n ≤ 105). The second line contains n integers: v1, v2, ..., vn (1 ≤ vi ≤ 109) — costs of the stones.
The third line contains an integer m (1 ≤ m ≤ 105) — the number of Kuriyama Mirai's questions. Then follow m lines, each line contains three integers type, l and r (1 ≤ l ≤ r ≤ n; 1 ≤ type ≤ 2), describing a question. If type equal to 1, then you should output the answer for the first question, else you should output the answer for the second one.
Output
Print m lines. Each line must contain an integer — the answer to Kuriyama Mirai's question. Print the answers to the questions in the order of input.
Examples
Input
6
6 4 2 7 2 7
3
2 3 6
1 3 4
1 1 6
Output
24
9
28
Input
4
5 5 2 3
10
1 2 4
2 1 4
1 1 1
2 1 4
2 1 2
1 1 1
1 3 3
1 1 3
1 4 4
1 2 2
Output
10
15
5
15
5
5
2
12
3
5
Note
Please note that the answers to the questions may overflow 32-bit integer type.
Submitted Solution:
```
"Codeforces Round #339 (Div. 2)"
"B. Gena's Code"
# y=int(input())
# # a=list(map(int,input().split()))
# a=list(input().split())
# nz=0
# nb=''
# z=0
# # print(len(str(z)))
# for i in a:
# if i=='0':
# z=1
# break
# else:
# s='1'
# l=(len(i)-1)
# qz='0'*l
# s+=qz
# if s==i:
# nz+=l
# else:
# nb=i
# if nb=='':
# nb='1'
# ans=nb+('0'*nz)
# if z==1:
# ans='0'
# print(ans)
"Codeforces Round #177 (Div. 2)"
"B. Polo the Penguin and Matrix"
# n,m,d=map(int,input().split())
# a=[]
# for i in range(n):
# b=list(map(int,input().split()))
# a.extend(b)
# a.sort()
# fa=a[0]
# f=0
# c=(a[len(a)//2]-fa)//d
# moves=0
# for i in a:
# if (i-fa)%d>0:
# f=-1
# moves+=abs(int((i-fa)/d)-c)
# if f==-1:
# print(-1)
# else:
# print(moves)
"Codeforces Round #264 (Div. 2)"
"B. Caisa and Pylons"
# y=int(input())
# a=list(map(int,input().split()))
# mini=0
# p=-a[0]
# for i in range(1,y):
# if p<mini:
# mini=p
# p=p+a[i-1]-a[i]
# if p<mini:
# mini=p
# if mini<0:
# print(-1*mini)
# else:
# print(0)
"Codeforces Beta Round #79 (Div. 2 Only)"
"B. Sum of Digits"
# y=input()
# def sumofdigits(s):
# ans=0
# for i in s:
# ans+=int(i)
# return ans
# n=0
# while len(y)>1:
# n+=1
# y=str(sumofdigits(y))
# print(n)
"Codeforces Beta Round #70 (Div. 2)"
"B. Easter Eggs"
# y=int(input())
# y=y-7
# s="ROYGBIV"
# sq=["G","B","I","V"]
# i=0
# while y>0:
# if i==4:
# i=0
# s+=sq[i]
# i+=1
# y-=1
# print(s)
"Codeforces Round #386 (Div. 2)"
"B. Decoding"
# y=int(input())
# sq=input()
# i=y%2
# s=""
# s+=sq[0]
# for j in range(1,y):
# if i==0:
# s+=sq[j]
# else:
# s=sq[j]+s
# i=1-i
# print(s)
"Codeforces Round #280 (Div. 2)"
"B. Vanya and Lanterns"
# n,l=map(int,input().split())
# a=list(map(int,input().split()))
# a.sort()
# max=float(a[0])
# for i in range(1,n):
# m=(a[i]-a[i-1])/2
# if max<m:
# max=m
# m=l-a[-1]
# if max<m:
# max=m
# print(max)
"Codeforces Round #248 (Div. 2)"
"B. Kuriyama Mirai's Stones"
y=int(input())
a=list(map(int,input().split()))
t1=int(input())
a1=[0]
for i in range(y):
a1.append(a1[-1]+a[i])
a.sort()
a2=[0]
for i in range(y):
a2.append(a2[-1]+a[i])
for i in range(t1):
t,l,r=map(int,input().split())
if t==1:
print(a1[r]-a1[l-1])
else:
print(a2[r]-a2[l-1])
```
|
instruction
| 0
| 2,835
| 2
| 5,670
|
Yes
|
output
| 1
| 2,835
| 2
| 5,671
|
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
Kuriyama Mirai has killed many monsters and got many (namely n) stones. She numbers the stones from 1 to n. The cost of the i-th stone is vi. Kuriyama Mirai wants to know something about these stones so she will ask you two kinds of questions:
1. She will tell you two numbers, l and r (1 ≤ l ≤ r ≤ n), and you should tell her <image>.
2. Let ui be the cost of the i-th cheapest stone (the cost that will be on the i-th place if we arrange all the stone costs in non-decreasing order). This time she will tell you two numbers, l and r (1 ≤ l ≤ r ≤ n), and you should tell her <image>.
For every question you should give the correct answer, or Kuriyama Mirai will say "fuyukai desu" and then become unhappy.
Input
The first line contains an integer n (1 ≤ n ≤ 105). The second line contains n integers: v1, v2, ..., vn (1 ≤ vi ≤ 109) — costs of the stones.
The third line contains an integer m (1 ≤ m ≤ 105) — the number of Kuriyama Mirai's questions. Then follow m lines, each line contains three integers type, l and r (1 ≤ l ≤ r ≤ n; 1 ≤ type ≤ 2), describing a question. If type equal to 1, then you should output the answer for the first question, else you should output the answer for the second one.
Output
Print m lines. Each line must contain an integer — the answer to Kuriyama Mirai's question. Print the answers to the questions in the order of input.
Examples
Input
6
6 4 2 7 2 7
3
2 3 6
1 3 4
1 1 6
Output
24
9
28
Input
4
5 5 2 3
10
1 2 4
2 1 4
1 1 1
2 1 4
2 1 2
1 1 1
1 3 3
1 1 3
1 4 4
1 2 2
Output
10
15
5
15
5
5
2
12
3
5
Note
Please note that the answers to the questions may overflow 32-bit integer type.
Submitted Solution:
```
n=int(input())
arr=input().split()
brr=sorted(arr,key=int)
for i in range(1,n):
arr[i]=int(arr[i-1])+int(arr[i])
for i in range(1,n):
brr[i]=int(brr[i-1])+int(brr[i])
m=int(input())
for i in range(m):
ty,l,r=map(int,input().split())
if ty==1:
if l-2>=0:
print(int(arr[r-1])-int(arr[l-2]))
else:
print(int(arr[r-1]))
else:
if l-2>=0:
print(int(brr[r-1])-int(brr[l-2]))
else:
print(int(brr[r-1]))
```
|
instruction
| 0
| 2,836
| 2
| 5,672
|
Yes
|
output
| 1
| 2,836
| 2
| 5,673
|
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
Kuriyama Mirai has killed many monsters and got many (namely n) stones. She numbers the stones from 1 to n. The cost of the i-th stone is vi. Kuriyama Mirai wants to know something about these stones so she will ask you two kinds of questions:
1. She will tell you two numbers, l and r (1 ≤ l ≤ r ≤ n), and you should tell her <image>.
2. Let ui be the cost of the i-th cheapest stone (the cost that will be on the i-th place if we arrange all the stone costs in non-decreasing order). This time she will tell you two numbers, l and r (1 ≤ l ≤ r ≤ n), and you should tell her <image>.
For every question you should give the correct answer, or Kuriyama Mirai will say "fuyukai desu" and then become unhappy.
Input
The first line contains an integer n (1 ≤ n ≤ 105). The second line contains n integers: v1, v2, ..., vn (1 ≤ vi ≤ 109) — costs of the stones.
The third line contains an integer m (1 ≤ m ≤ 105) — the number of Kuriyama Mirai's questions. Then follow m lines, each line contains three integers type, l and r (1 ≤ l ≤ r ≤ n; 1 ≤ type ≤ 2), describing a question. If type equal to 1, then you should output the answer for the first question, else you should output the answer for the second one.
Output
Print m lines. Each line must contain an integer — the answer to Kuriyama Mirai's question. Print the answers to the questions in the order of input.
Examples
Input
6
6 4 2 7 2 7
3
2 3 6
1 3 4
1 1 6
Output
24
9
28
Input
4
5 5 2 3
10
1 2 4
2 1 4
1 1 1
2 1 4
2 1 2
1 1 1
1 3 3
1 1 3
1 4 4
1 2 2
Output
10
15
5
15
5
5
2
12
3
5
Note
Please note that the answers to the questions may overflow 32-bit integer type.
Submitted Solution:
```
n= int(input())
mas1 = list(map(int,input().split(" ")))
mas2 = sorted(mas1)
for i in range(1,n):
mas1[i]+=mas1[i-1]
mas2[i]+=mas2[i-1]
m = int(input())
mas1.append(0)
mas2.append(0)
print("\n".join(map(str, (mas1[b-1]-mas1[a-2] if s==1 else mas2[b-1]-mas2[a-2] for s, a, b in (map(int,input().split(" ")) for i in range(m))))))
```
|
instruction
| 0
| 2,837
| 2
| 5,674
|
Yes
|
output
| 1
| 2,837
| 2
| 5,675
|
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
Kuriyama Mirai has killed many monsters and got many (namely n) stones. She numbers the stones from 1 to n. The cost of the i-th stone is vi. Kuriyama Mirai wants to know something about these stones so she will ask you two kinds of questions:
1. She will tell you two numbers, l and r (1 ≤ l ≤ r ≤ n), and you should tell her <image>.
2. Let ui be the cost of the i-th cheapest stone (the cost that will be on the i-th place if we arrange all the stone costs in non-decreasing order). This time she will tell you two numbers, l and r (1 ≤ l ≤ r ≤ n), and you should tell her <image>.
For every question you should give the correct answer, or Kuriyama Mirai will say "fuyukai desu" and then become unhappy.
Input
The first line contains an integer n (1 ≤ n ≤ 105). The second line contains n integers: v1, v2, ..., vn (1 ≤ vi ≤ 109) — costs of the stones.
The third line contains an integer m (1 ≤ m ≤ 105) — the number of Kuriyama Mirai's questions. Then follow m lines, each line contains three integers type, l and r (1 ≤ l ≤ r ≤ n; 1 ≤ type ≤ 2), describing a question. If type equal to 1, then you should output the answer for the first question, else you should output the answer for the second one.
Output
Print m lines. Each line must contain an integer — the answer to Kuriyama Mirai's question. Print the answers to the questions in the order of input.
Examples
Input
6
6 4 2 7 2 7
3
2 3 6
1 3 4
1 1 6
Output
24
9
28
Input
4
5 5 2 3
10
1 2 4
2 1 4
1 1 1
2 1 4
2 1 2
1 1 1
1 3 3
1 1 3
1 4 4
1 2 2
Output
10
15
5
15
5
5
2
12
3
5
Note
Please note that the answers to the questions may overflow 32-bit integer type.
Submitted Solution:
```
n = int(input())
arr = [0]
for x in input().split():
arr.append(int(x))
ac = [0]
for i in range(1,n+1):
ac.append(arr[i] + ac[i-1])
arr.sort()
acSorted = [0]
for i in range(1,n+1):
acSorted.append(arr[i] + acSorted[i-1])
m = int(input())
for i in range(m):
op, l, r = map(int, input().split())
if (op == 1):
print(ac[r] - ac[l-1])
else:
print(acSorted[r] - acSorted[l-1])
# 1481936527735
```
|
instruction
| 0
| 2,838
| 2
| 5,676
|
Yes
|
output
| 1
| 2,838
| 2
| 5,677
|
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
Kuriyama Mirai has killed many monsters and got many (namely n) stones. She numbers the stones from 1 to n. The cost of the i-th stone is vi. Kuriyama Mirai wants to know something about these stones so she will ask you two kinds of questions:
1. She will tell you two numbers, l and r (1 ≤ l ≤ r ≤ n), and you should tell her <image>.
2. Let ui be the cost of the i-th cheapest stone (the cost that will be on the i-th place if we arrange all the stone costs in non-decreasing order). This time she will tell you two numbers, l and r (1 ≤ l ≤ r ≤ n), and you should tell her <image>.
For every question you should give the correct answer, or Kuriyama Mirai will say "fuyukai desu" and then become unhappy.
Input
The first line contains an integer n (1 ≤ n ≤ 105). The second line contains n integers: v1, v2, ..., vn (1 ≤ vi ≤ 109) — costs of the stones.
The third line contains an integer m (1 ≤ m ≤ 105) — the number of Kuriyama Mirai's questions. Then follow m lines, each line contains three integers type, l and r (1 ≤ l ≤ r ≤ n; 1 ≤ type ≤ 2), describing a question. If type equal to 1, then you should output the answer for the first question, else you should output the answer for the second one.
Output
Print m lines. Each line must contain an integer — the answer to Kuriyama Mirai's question. Print the answers to the questions in the order of input.
Examples
Input
6
6 4 2 7 2 7
3
2 3 6
1 3 4
1 1 6
Output
24
9
28
Input
4
5 5 2 3
10
1 2 4
2 1 4
1 1 1
2 1 4
2 1 2
1 1 1
1 3 3
1 1 3
1 4 4
1 2 2
Output
10
15
5
15
5
5
2
12
3
5
Note
Please note that the answers to the questions may overflow 32-bit integer type.
Submitted Solution:
```
n = int(input())
data1 = input().split();
x = 0
for x in range(len(data1)):
data1[x] = int(data1[x])
data2 = data1[:]
data2.sort();
k = int(input())
def query1(fr, to):
sum = 0
for x in data1[fr:to+1]:
sum += x
print("outs: ",sum)
x = 0
def query2(fr, to):
sum = 0
for x in data2[fr:to+1]:
sum += x
print("outs: ",sum)
while x < k:
data3 = input().split();
if(int(data3[0]) is 1):
query1(int(data3[1])-1, int(data3[2])-1)
else:
query2(int(data3[1])-1, int(data3[2])-1)
x+=1
```
|
instruction
| 0
| 2,839
| 2
| 5,678
|
No
|
output
| 1
| 2,839
| 2
| 5,679
|
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
Kuriyama Mirai has killed many monsters and got many (namely n) stones. She numbers the stones from 1 to n. The cost of the i-th stone is vi. Kuriyama Mirai wants to know something about these stones so she will ask you two kinds of questions:
1. She will tell you two numbers, l and r (1 ≤ l ≤ r ≤ n), and you should tell her <image>.
2. Let ui be the cost of the i-th cheapest stone (the cost that will be on the i-th place if we arrange all the stone costs in non-decreasing order). This time she will tell you two numbers, l and r (1 ≤ l ≤ r ≤ n), and you should tell her <image>.
For every question you should give the correct answer, or Kuriyama Mirai will say "fuyukai desu" and then become unhappy.
Input
The first line contains an integer n (1 ≤ n ≤ 105). The second line contains n integers: v1, v2, ..., vn (1 ≤ vi ≤ 109) — costs of the stones.
The third line contains an integer m (1 ≤ m ≤ 105) — the number of Kuriyama Mirai's questions. Then follow m lines, each line contains three integers type, l and r (1 ≤ l ≤ r ≤ n; 1 ≤ type ≤ 2), describing a question. If type equal to 1, then you should output the answer for the first question, else you should output the answer for the second one.
Output
Print m lines. Each line must contain an integer — the answer to Kuriyama Mirai's question. Print the answers to the questions in the order of input.
Examples
Input
6
6 4 2 7 2 7
3
2 3 6
1 3 4
1 1 6
Output
24
9
28
Input
4
5 5 2 3
10
1 2 4
2 1 4
1 1 1
2 1 4
2 1 2
1 1 1
1 3 3
1 1 3
1 4 4
1 2 2
Output
10
15
5
15
5
5
2
12
3
5
Note
Please note that the answers to the questions may overflow 32-bit integer type.
Submitted Solution:
```
def rat(b,x,y):print(b[y]-b[x-1])
a=int(input())
b=[0]+list(map(int,input().split()))
c=sorted(b.copy())
for i in range(1,a+1):b[i]+=b[i-1];c[i]+=c[i-1]
for _ in " "*int(input()):
x,y,z=map(int,input().split())
if x==1:rat(b,y,z)
else:rat(c,x,y)
```
|
instruction
| 0
| 2,840
| 2
| 5,680
|
No
|
output
| 1
| 2,840
| 2
| 5,681
|
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
Kuriyama Mirai has killed many monsters and got many (namely n) stones. She numbers the stones from 1 to n. The cost of the i-th stone is vi. Kuriyama Mirai wants to know something about these stones so she will ask you two kinds of questions:
1. She will tell you two numbers, l and r (1 ≤ l ≤ r ≤ n), and you should tell her <image>.
2. Let ui be the cost of the i-th cheapest stone (the cost that will be on the i-th place if we arrange all the stone costs in non-decreasing order). This time she will tell you two numbers, l and r (1 ≤ l ≤ r ≤ n), and you should tell her <image>.
For every question you should give the correct answer, or Kuriyama Mirai will say "fuyukai desu" and then become unhappy.
Input
The first line contains an integer n (1 ≤ n ≤ 105). The second line contains n integers: v1, v2, ..., vn (1 ≤ vi ≤ 109) — costs of the stones.
The third line contains an integer m (1 ≤ m ≤ 105) — the number of Kuriyama Mirai's questions. Then follow m lines, each line contains three integers type, l and r (1 ≤ l ≤ r ≤ n; 1 ≤ type ≤ 2), describing a question. If type equal to 1, then you should output the answer for the first question, else you should output the answer for the second one.
Output
Print m lines. Each line must contain an integer — the answer to Kuriyama Mirai's question. Print the answers to the questions in the order of input.
Examples
Input
6
6 4 2 7 2 7
3
2 3 6
1 3 4
1 1 6
Output
24
9
28
Input
4
5 5 2 3
10
1 2 4
2 1 4
1 1 1
2 1 4
2 1 2
1 1 1
1 3 3
1 1 3
1 4 4
1 2 2
Output
10
15
5
15
5
5
2
12
3
5
Note
Please note that the answers to the questions may overflow 32-bit integer type.
Submitted Solution:
```
def lista_acumulada(lista):
lista[0] = int(lista[0])
i = 1
while i < len(lista):
lista[i] = int(lista[i]) + int(lista[i - 1])
i += 1
return lista
n = int(input())
entrada = input()
m = int(input())
questoes = []
res = []
i = 0
while i < m:
questoes.append(input().split())
i += 1
acumulada1 = lista_acumulada(entrada.split())
acumulada2 = lista_acumulada(sorted(entrada.split()))
for e in questoes:
l = int(e[1])
r = int(e[2])
if e[0] == '1':
if l == 1:
res.append(acumulada1[r - 1])
else:
res.append(acumulada1[r - 1] - acumulada1[l - 2]) # na entrada os indices (l, r) são contados a partir do 1
else:
if l == 1:
res.append(acumulada2[r - 1])
else:
res.append(acumulada2[r - 1] - acumulada2[l - 2])
for e in res:
print(e)
```
|
instruction
| 0
| 2,841
| 2
| 5,682
|
No
|
output
| 1
| 2,841
| 2
| 5,683
|
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
Kuriyama Mirai has killed many monsters and got many (namely n) stones. She numbers the stones from 1 to n. The cost of the i-th stone is vi. Kuriyama Mirai wants to know something about these stones so she will ask you two kinds of questions:
1. She will tell you two numbers, l and r (1 ≤ l ≤ r ≤ n), and you should tell her <image>.
2. Let ui be the cost of the i-th cheapest stone (the cost that will be on the i-th place if we arrange all the stone costs in non-decreasing order). This time she will tell you two numbers, l and r (1 ≤ l ≤ r ≤ n), and you should tell her <image>.
For every question you should give the correct answer, or Kuriyama Mirai will say "fuyukai desu" and then become unhappy.
Input
The first line contains an integer n (1 ≤ n ≤ 105). The second line contains n integers: v1, v2, ..., vn (1 ≤ vi ≤ 109) — costs of the stones.
The third line contains an integer m (1 ≤ m ≤ 105) — the number of Kuriyama Mirai's questions. Then follow m lines, each line contains three integers type, l and r (1 ≤ l ≤ r ≤ n; 1 ≤ type ≤ 2), describing a question. If type equal to 1, then you should output the answer for the first question, else you should output the answer for the second one.
Output
Print m lines. Each line must contain an integer — the answer to Kuriyama Mirai's question. Print the answers to the questions in the order of input.
Examples
Input
6
6 4 2 7 2 7
3
2 3 6
1 3 4
1 1 6
Output
24
9
28
Input
4
5 5 2 3
10
1 2 4
2 1 4
1 1 1
2 1 4
2 1 2
1 1 1
1 3 3
1 1 3
1 4 4
1 2 2
Output
10
15
5
15
5
5
2
12
3
5
Note
Please note that the answers to the questions may overflow 32-bit integer type.
Submitted Solution:
```
def sumLisNum(lis):
sumLis = [0] * len(lis)
sumLis[0] = lis[0]
for i in range(1, len(lis)):
sumLis[i] = sumLis[i - 1] + lis[i]
return sumLis
n = int(input())
v = list(map(int, input().split()))
u = v[:]
u.sort()
sumV = sumLisNum(v)
sumU = sumLisNum(u)
m = int(input())
print(sumV)
print(sumU)
for i in range(m):
t, l, r = map(int, input().split())
if t == 1:
print(sumV[r - 1] - sumV[l - 1] + v[l - 1])
else:
print(sumU[r - 1] - sumU[l - 1] + u[l - 1])
```
|
instruction
| 0
| 2,842
| 2
| 5,684
|
No
|
output
| 1
| 2,842
| 2
| 5,685
|
Provide tags and a correct Python 3 solution for this coding contest problem.
Professor Dumbledore is helping Harry destroy the Horcruxes. He went to Gaunt Shack as he suspected a Horcrux to be present there. He saw Marvolo Gaunt's Ring and identified it as a Horcrux. Although he destroyed it, he is still affected by its curse. Professor Snape is helping Dumbledore remove the curse. For this, he wants to give Dumbledore exactly x drops of the potion he made.
Value of x is calculated as maximum of p·ai + q·aj + r·ak for given p, q, r and array a1, a2, ... an such that 1 ≤ i ≤ j ≤ k ≤ n. Help Snape find the value of x. Do note that the value of x may be negative.
Input
First line of input contains 4 integers n, p, q, r ( - 109 ≤ p, q, r ≤ 109, 1 ≤ n ≤ 105).
Next line of input contains n space separated integers a1, a2, ... an ( - 109 ≤ ai ≤ 109).
Output
Output a single integer the maximum value of p·ai + q·aj + r·ak that can be obtained provided 1 ≤ i ≤ j ≤ k ≤ n.
Examples
Input
5 1 2 3
1 2 3 4 5
Output
30
Input
5 1 2 -3
-1 -2 -3 -4 -5
Output
12
Note
In the first sample case, we can take i = j = k = 5, thus making the answer as 1·5 + 2·5 + 3·5 = 30.
In second sample case, selecting i = j = 1 and k = 5 gives the answer 12.
|
instruction
| 0
| 3,866
| 2
| 7,732
|
Tags: brute force, data structures, dp
Correct Solution:
```
import bisect
from itertools import accumulate, count
import os
import sys
import math
from decimal import *
from io import BytesIO, IOBase
from sys import maxsize
BUFSIZE = 8192
class FastIO(IOBase):
newlines = 0
def __init__(self, file):
self._fd = file.fileno()
self.buffer = BytesIO()
self.writable = "x" in file.mode or "r" not in file.mode
self.write = self.buffer.write if self.writable else None
def read(self):
while True:
b = os.read(self._fd, max(os.fstat(self._fd).st_size, BUFSIZE))
if not b:
break
ptr = self.buffer.tell()
self.buffer.seek(0, 2), self.buffer.write(b), self.buffer.seek(ptr)
self.newlines = 0
return self.buffer.read()
def readline(self):
while self.newlines == 0:
b = os.read(self._fd, max(os.fstat(self._fd).st_size, BUFSIZE))
self.newlines = b.count(b"\n") + (not b)
ptr = self.buffer.tell()
self.buffer.seek(0, 2), self.buffer.write(b), self.buffer.seek(ptr)
self.newlines -= 1
return self.buffer.readline()
def flush(self):
if self.writable:
os.write(self._fd, self.buffer.getvalue())
self.buffer.truncate(0), self.buffer.seek(0)
class IOWrapper(IOBase):
def __init__(self, file):
self.buffer = FastIO(file)
self.flush = self.buffer.flush
self.writable = self.buffer.writable
self.write = lambda s: self.buffer.write(s.encode("ascii"))
self.read = lambda: self.buffer.read().decode("ascii")
self.readline = lambda: self.buffer.readline().decode("ascii")
sys.stdin, sys.stdout = IOWrapper(sys.stdin), IOWrapper(sys.stdout)
def input():
return sys.stdin.readline().rstrip("\r\n")
def isPrime(n):
if n <= 1:
return False
if n <= 3:
return True
if n % 2 == 0 or n % 3 == 0:
return False
i = 5
while i * i <= n:
if n % i == 0 or n % (i + 2) == 0:
return False
i = i + 6
return True
def SieveOfEratosthenes(n):
prime = []
primes = [True for i in range(n + 1)]
p = 2
while p * p <= n:
if primes[p] == True:
prime.append(p)
for i in range(p * p, n + 1, p):
primes[i] = False
p += 1
return prime
def primefactors(n):
fac = []
while n % 2 == 0:
fac.append(2)
n = n // 2
for i in range(3, int(math.sqrt(n)) + 2):
while n % i == 0:
fac.append(i)
n = n // i
if n > 1:
fac.append(n)
return sorted(fac)
def factors(n):
fac = set()
fac.add(1)
fac.add(n)
for i in range(2, int(math.sqrt(n)) + 1):
if n % i == 0:
fac.add(i)
fac.add(n // i)
return list(fac)
def modInverse(a, m):
m0 = m
y = 0
x = 1
if m == 1:
return 0
while a > 1:
q = a // m
t = m
m = a % m
a = t
t = y
y = x - q * y
x = t
if x < 0:
x = x + m0
return x
# ------------------------------------------------------code
n,p,q,r=map(int,input().split())
dp=[[0]*(n+1)]*4
a=list(map(int,input().split()))
ans1=-1e22
ans2=-1e22
ans3=-1e22
for i in a:
ans1=max(ans1,p*i)
ans2=max(ans2,ans1+q*i)
ans3=max(ans3,ans2+r*i)
print(ans3)
```
|
output
| 1
| 3,866
| 2
| 7,733
|
Provide tags and a correct Python 3 solution for this coding contest problem.
Professor Dumbledore is helping Harry destroy the Horcruxes. He went to Gaunt Shack as he suspected a Horcrux to be present there. He saw Marvolo Gaunt's Ring and identified it as a Horcrux. Although he destroyed it, he is still affected by its curse. Professor Snape is helping Dumbledore remove the curse. For this, he wants to give Dumbledore exactly x drops of the potion he made.
Value of x is calculated as maximum of p·ai + q·aj + r·ak for given p, q, r and array a1, a2, ... an such that 1 ≤ i ≤ j ≤ k ≤ n. Help Snape find the value of x. Do note that the value of x may be negative.
Input
First line of input contains 4 integers n, p, q, r ( - 109 ≤ p, q, r ≤ 109, 1 ≤ n ≤ 105).
Next line of input contains n space separated integers a1, a2, ... an ( - 109 ≤ ai ≤ 109).
Output
Output a single integer the maximum value of p·ai + q·aj + r·ak that can be obtained provided 1 ≤ i ≤ j ≤ k ≤ n.
Examples
Input
5 1 2 3
1 2 3 4 5
Output
30
Input
5 1 2 -3
-1 -2 -3 -4 -5
Output
12
Note
In the first sample case, we can take i = j = k = 5, thus making the answer as 1·5 + 2·5 + 3·5 = 30.
In second sample case, selecting i = j = 1 and k = 5 gives the answer 12.
|
instruction
| 0
| 3,867
| 2
| 7,734
|
Tags: brute force, data structures, dp
Correct Solution:
```
n,p,q,r=map(int,input().split())
arr=list(map(int,input().split()))
arr1=[p*arr[0]]
for i in range(1,n):
arr1.append(max(p*arr[i],arr1[-1]))
arr2=[arr1[0]+(q*arr[0])]
for i in range(1,n):
arr2.append(max(arr2[-1],arr1[i]+(q*arr[i])))
arr3=[arr2[0]+(r*arr[0])]
for i in range(1,n):
arr3.append(max(arr3[-1],arr2[i]+(r*arr[i])))
print(arr3[-1])
```
|
output
| 1
| 3,867
| 2
| 7,735
|
Provide tags and a correct Python 3 solution for this coding contest problem.
Professor Dumbledore is helping Harry destroy the Horcruxes. He went to Gaunt Shack as he suspected a Horcrux to be present there. He saw Marvolo Gaunt's Ring and identified it as a Horcrux. Although he destroyed it, he is still affected by its curse. Professor Snape is helping Dumbledore remove the curse. For this, he wants to give Dumbledore exactly x drops of the potion he made.
Value of x is calculated as maximum of p·ai + q·aj + r·ak for given p, q, r and array a1, a2, ... an such that 1 ≤ i ≤ j ≤ k ≤ n. Help Snape find the value of x. Do note that the value of x may be negative.
Input
First line of input contains 4 integers n, p, q, r ( - 109 ≤ p, q, r ≤ 109, 1 ≤ n ≤ 105).
Next line of input contains n space separated integers a1, a2, ... an ( - 109 ≤ ai ≤ 109).
Output
Output a single integer the maximum value of p·ai + q·aj + r·ak that can be obtained provided 1 ≤ i ≤ j ≤ k ≤ n.
Examples
Input
5 1 2 3
1 2 3 4 5
Output
30
Input
5 1 2 -3
-1 -2 -3 -4 -5
Output
12
Note
In the first sample case, we can take i = j = k = 5, thus making the answer as 1·5 + 2·5 + 3·5 = 30.
In second sample case, selecting i = j = 1 and k = 5 gives the answer 12.
|
instruction
| 0
| 3,868
| 2
| 7,736
|
Tags: brute force, data structures, dp
Correct Solution:
```
n,p,q,r=map(int,input().split())
arr = list(map(int,input().split()))
n=len(arr)
if n==1:
print(arr[0]*(p+q+r))
else:
pref=[arr[0]]
if(p>0):
for i in range(1,n):
pref.append(max(pref[-1],arr[i]))
else:
for i in range(1,n):
pref.append(min(pref[-1],arr[i]))
suff=[arr[-1]]
if(r>0):
for i in range(n-2,-1,-1):
suff.append(max(suff[-1],arr[i]))
else:
for i in range(n-2,-1,-1):
suff.append(min(suff[-1],arr[i]))
suff=suff[::-1]
ans= float('-inf')
for i in range(n):
ans=max(ans, p*pref[i]+q*arr[i]+r*suff[i])
print(ans)
```
|
output
| 1
| 3,868
| 2
| 7,737
|
Provide tags and a correct Python 3 solution for this coding contest problem.
Professor Dumbledore is helping Harry destroy the Horcruxes. He went to Gaunt Shack as he suspected a Horcrux to be present there. He saw Marvolo Gaunt's Ring and identified it as a Horcrux. Although he destroyed it, he is still affected by its curse. Professor Snape is helping Dumbledore remove the curse. For this, he wants to give Dumbledore exactly x drops of the potion he made.
Value of x is calculated as maximum of p·ai + q·aj + r·ak for given p, q, r and array a1, a2, ... an such that 1 ≤ i ≤ j ≤ k ≤ n. Help Snape find the value of x. Do note that the value of x may be negative.
Input
First line of input contains 4 integers n, p, q, r ( - 109 ≤ p, q, r ≤ 109, 1 ≤ n ≤ 105).
Next line of input contains n space separated integers a1, a2, ... an ( - 109 ≤ ai ≤ 109).
Output
Output a single integer the maximum value of p·ai + q·aj + r·ak that can be obtained provided 1 ≤ i ≤ j ≤ k ≤ n.
Examples
Input
5 1 2 3
1 2 3 4 5
Output
30
Input
5 1 2 -3
-1 -2 -3 -4 -5
Output
12
Note
In the first sample case, we can take i = j = k = 5, thus making the answer as 1·5 + 2·5 + 3·5 = 30.
In second sample case, selecting i = j = 1 and k = 5 gives the answer 12.
|
instruction
| 0
| 3,869
| 2
| 7,738
|
Tags: brute force, data structures, dp
Correct Solution:
```
x = list(map(int, input().split()))
n = x[0]
x[0] = 0
data = list(map(int, input().split()))
ans = [-(10 ** 19)] * 4
ans[0] = 0
for i in data:
for j in range(1, 4):
ans[j] = max(ans[j], ans[j-1] + x[j] * i)
print(ans[3])
```
|
output
| 1
| 3,869
| 2
| 7,739
|
Provide tags and a correct Python 3 solution for this coding contest problem.
Professor Dumbledore is helping Harry destroy the Horcruxes. He went to Gaunt Shack as he suspected a Horcrux to be present there. He saw Marvolo Gaunt's Ring and identified it as a Horcrux. Although he destroyed it, he is still affected by its curse. Professor Snape is helping Dumbledore remove the curse. For this, he wants to give Dumbledore exactly x drops of the potion he made.
Value of x is calculated as maximum of p·ai + q·aj + r·ak for given p, q, r and array a1, a2, ... an such that 1 ≤ i ≤ j ≤ k ≤ n. Help Snape find the value of x. Do note that the value of x may be negative.
Input
First line of input contains 4 integers n, p, q, r ( - 109 ≤ p, q, r ≤ 109, 1 ≤ n ≤ 105).
Next line of input contains n space separated integers a1, a2, ... an ( - 109 ≤ ai ≤ 109).
Output
Output a single integer the maximum value of p·ai + q·aj + r·ak that can be obtained provided 1 ≤ i ≤ j ≤ k ≤ n.
Examples
Input
5 1 2 3
1 2 3 4 5
Output
30
Input
5 1 2 -3
-1 -2 -3 -4 -5
Output
12
Note
In the first sample case, we can take i = j = k = 5, thus making the answer as 1·5 + 2·5 + 3·5 = 30.
In second sample case, selecting i = j = 1 and k = 5 gives the answer 12.
|
instruction
| 0
| 3,870
| 2
| 7,740
|
Tags: brute force, data structures, dp
Correct Solution:
```
nn, p, q, r = map(int, input().split())
ar = list(map(int, input().split()))
max_l = [ar[0]]
for i in range(1, nn):
max_l.append(max(max_l[-1], ar[i]))
min_l = [ar[0]]
for i in range(1, nn):
min_l.append(min(min_l[-1], ar[i]))
max_r = [0] * nn
max_r[-1] = ar[-1]
for i in range(nn - 2, -1, -1):
max_r[i] = max(max_r[i + 1], ar[i])
min_r = [0] * nn
min_r[-1] = ar[-1]
for i in range(nn - 2, -1, -1):
min_r[i] = min(min_r[i + 1], ar[i])
ans = -3 * 10 ** 19
for i in range(0, nn):
t = q * ar[i]
t += p * (min_l[i] if p < 0 else max_l[i])
t += r * (min_r[i] if r < 0 else max_r[i])
ans = max(ans, t)
print(ans)
```
|
output
| 1
| 3,870
| 2
| 7,741
|
Provide tags and a correct Python 3 solution for this coding contest problem.
Professor Dumbledore is helping Harry destroy the Horcruxes. He went to Gaunt Shack as he suspected a Horcrux to be present there. He saw Marvolo Gaunt's Ring and identified it as a Horcrux. Although he destroyed it, he is still affected by its curse. Professor Snape is helping Dumbledore remove the curse. For this, he wants to give Dumbledore exactly x drops of the potion he made.
Value of x is calculated as maximum of p·ai + q·aj + r·ak for given p, q, r and array a1, a2, ... an such that 1 ≤ i ≤ j ≤ k ≤ n. Help Snape find the value of x. Do note that the value of x may be negative.
Input
First line of input contains 4 integers n, p, q, r ( - 109 ≤ p, q, r ≤ 109, 1 ≤ n ≤ 105).
Next line of input contains n space separated integers a1, a2, ... an ( - 109 ≤ ai ≤ 109).
Output
Output a single integer the maximum value of p·ai + q·aj + r·ak that can be obtained provided 1 ≤ i ≤ j ≤ k ≤ n.
Examples
Input
5 1 2 3
1 2 3 4 5
Output
30
Input
5 1 2 -3
-1 -2 -3 -4 -5
Output
12
Note
In the first sample case, we can take i = j = k = 5, thus making the answer as 1·5 + 2·5 + 3·5 = 30.
In second sample case, selecting i = j = 1 and k = 5 gives the answer 12.
|
instruction
| 0
| 3,871
| 2
| 7,742
|
Tags: brute force, data structures, dp
Correct Solution:
```
n, p, q, r = [int(i) for i in input().split()]
a = [int(i) for i in input().split()]
crmx, crmn = [a[n - 1]] * n, [a[n - 1]] * n
for i in range(n - 2, -1, -1):
crmx[i] = max(crmx[i + 1], a[i])
crmn[i] = min(crmn[i + 1], a[i])
ans = 0 - 10 ** 21
mn, mx = a[0], a[0]
for i in range(n):
cans = q * a[i]
mx = max(mx, a[i])
mn = min(mn, a[i])
cans += max(mx * p, mn * p)
cans += max(crmx[i] * r, crmn[i] * r)
ans = max(ans, cans)
print(ans)
```
|
output
| 1
| 3,871
| 2
| 7,743
|
Provide tags and a correct Python 3 solution for this coding contest problem.
Professor Dumbledore is helping Harry destroy the Horcruxes. He went to Gaunt Shack as he suspected a Horcrux to be present there. He saw Marvolo Gaunt's Ring and identified it as a Horcrux. Although he destroyed it, he is still affected by its curse. Professor Snape is helping Dumbledore remove the curse. For this, he wants to give Dumbledore exactly x drops of the potion he made.
Value of x is calculated as maximum of p·ai + q·aj + r·ak for given p, q, r and array a1, a2, ... an such that 1 ≤ i ≤ j ≤ k ≤ n. Help Snape find the value of x. Do note that the value of x may be negative.
Input
First line of input contains 4 integers n, p, q, r ( - 109 ≤ p, q, r ≤ 109, 1 ≤ n ≤ 105).
Next line of input contains n space separated integers a1, a2, ... an ( - 109 ≤ ai ≤ 109).
Output
Output a single integer the maximum value of p·ai + q·aj + r·ak that can be obtained provided 1 ≤ i ≤ j ≤ k ≤ n.
Examples
Input
5 1 2 3
1 2 3 4 5
Output
30
Input
5 1 2 -3
-1 -2 -3 -4 -5
Output
12
Note
In the first sample case, we can take i = j = k = 5, thus making the answer as 1·5 + 2·5 + 3·5 = 30.
In second sample case, selecting i = j = 1 and k = 5 gives the answer 12.
|
instruction
| 0
| 3,872
| 2
| 7,744
|
Tags: brute force, data structures, dp
Correct Solution:
```
import sys
n,p,q,r=map(int,input().split())
arr=list(map(int,input().split()))
suffix_max=[0]*n
suffix_max[n-1]=r*arr[n-1]
for i in range(n-2,-1,-1):
suffix_max[i]=max(suffix_max[i+1],r*arr[i])
max_left=-1*sys.maxsize*(10**15)
ans=-1*sys.maxsize*(10**15)
for j in range(0,n):
max_left=max(max_left,p*arr[j])
max_right=suffix_max[j]
max_value_1=q*arr[j]
ans=max(ans,max_left+max_right+max_value_1)
print(ans)
```
|
output
| 1
| 3,872
| 2
| 7,745
|
Provide tags and a correct Python 3 solution for this coding contest problem.
Professor Dumbledore is helping Harry destroy the Horcruxes. He went to Gaunt Shack as he suspected a Horcrux to be present there. He saw Marvolo Gaunt's Ring and identified it as a Horcrux. Although he destroyed it, he is still affected by its curse. Professor Snape is helping Dumbledore remove the curse. For this, he wants to give Dumbledore exactly x drops of the potion he made.
Value of x is calculated as maximum of p·ai + q·aj + r·ak for given p, q, r and array a1, a2, ... an such that 1 ≤ i ≤ j ≤ k ≤ n. Help Snape find the value of x. Do note that the value of x may be negative.
Input
First line of input contains 4 integers n, p, q, r ( - 109 ≤ p, q, r ≤ 109, 1 ≤ n ≤ 105).
Next line of input contains n space separated integers a1, a2, ... an ( - 109 ≤ ai ≤ 109).
Output
Output a single integer the maximum value of p·ai + q·aj + r·ak that can be obtained provided 1 ≤ i ≤ j ≤ k ≤ n.
Examples
Input
5 1 2 3
1 2 3 4 5
Output
30
Input
5 1 2 -3
-1 -2 -3 -4 -5
Output
12
Note
In the first sample case, we can take i = j = k = 5, thus making the answer as 1·5 + 2·5 + 3·5 = 30.
In second sample case, selecting i = j = 1 and k = 5 gives the answer 12.
|
instruction
| 0
| 3,873
| 2
| 7,746
|
Tags: brute force, data structures, dp
Correct Solution:
```
n,p,q,r = map(int,input().split())
alist = list(map(int,input().split()))
a,b,c = -8e18,-8e18,-8e18
for i in range(n):
a = max(a, alist[i]*p)
b = max(b, a+alist[i]*q)
c = max(c, b+alist[i]*r)
print(c)
```
|
output
| 1
| 3,873
| 2
| 7,747
|
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
Professor Dumbledore is helping Harry destroy the Horcruxes. He went to Gaunt Shack as he suspected a Horcrux to be present there. He saw Marvolo Gaunt's Ring and identified it as a Horcrux. Although he destroyed it, he is still affected by its curse. Professor Snape is helping Dumbledore remove the curse. For this, he wants to give Dumbledore exactly x drops of the potion he made.
Value of x is calculated as maximum of p·ai + q·aj + r·ak for given p, q, r and array a1, a2, ... an such that 1 ≤ i ≤ j ≤ k ≤ n. Help Snape find the value of x. Do note that the value of x may be negative.
Input
First line of input contains 4 integers n, p, q, r ( - 109 ≤ p, q, r ≤ 109, 1 ≤ n ≤ 105).
Next line of input contains n space separated integers a1, a2, ... an ( - 109 ≤ ai ≤ 109).
Output
Output a single integer the maximum value of p·ai + q·aj + r·ak that can be obtained provided 1 ≤ i ≤ j ≤ k ≤ n.
Examples
Input
5 1 2 3
1 2 3 4 5
Output
30
Input
5 1 2 -3
-1 -2 -3 -4 -5
Output
12
Note
In the first sample case, we can take i = j = k = 5, thus making the answer as 1·5 + 2·5 + 3·5 = 30.
In second sample case, selecting i = j = 1 and k = 5 gives the answer 12.
Submitted Solution:
```
a = [int(x) for x in input().split()]
b = [int(y) for y in input().split()]
n = a[0]
p,q,r = a[1], a[2], a[3]
left = []
right = []
for i in range(n):
left.append(b[i]*p)
right.append(b[i]*r)
prefixMax = [0]*n
temp = -10000000000000000000
i = 0
while i < n:
temp = max(temp,left[i])
prefixMax[i] = temp
i += 1
temp = -10000000000000000000
suffixMax = [0]*n
i = n - 1
while i >= 0:
temp = max(temp, right[i])
suffixMax[i] = temp
i -= 1
ans = -10000000000000000000
for j in range(n):
aJ = q*b[j]
lMax = prefixMax[j]
rMax = suffixMax[j]
s = aJ + lMax + rMax
ans = max(ans, s)
print(ans)
```
|
instruction
| 0
| 3,874
| 2
| 7,748
|
Yes
|
output
| 1
| 3,874
| 2
| 7,749
|
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
Professor Dumbledore is helping Harry destroy the Horcruxes. He went to Gaunt Shack as he suspected a Horcrux to be present there. He saw Marvolo Gaunt's Ring and identified it as a Horcrux. Although he destroyed it, he is still affected by its curse. Professor Snape is helping Dumbledore remove the curse. For this, he wants to give Dumbledore exactly x drops of the potion he made.
Value of x is calculated as maximum of p·ai + q·aj + r·ak for given p, q, r and array a1, a2, ... an such that 1 ≤ i ≤ j ≤ k ≤ n. Help Snape find the value of x. Do note that the value of x may be negative.
Input
First line of input contains 4 integers n, p, q, r ( - 109 ≤ p, q, r ≤ 109, 1 ≤ n ≤ 105).
Next line of input contains n space separated integers a1, a2, ... an ( - 109 ≤ ai ≤ 109).
Output
Output a single integer the maximum value of p·ai + q·aj + r·ak that can be obtained provided 1 ≤ i ≤ j ≤ k ≤ n.
Examples
Input
5 1 2 3
1 2 3 4 5
Output
30
Input
5 1 2 -3
-1 -2 -3 -4 -5
Output
12
Note
In the first sample case, we can take i = j = k = 5, thus making the answer as 1·5 + 2·5 + 3·5 = 30.
In second sample case, selecting i = j = 1 and k = 5 gives the answer 12.
Submitted Solution:
```
# -*- coding: utf-8 -*-
"""
Created on Sun Sep 24 20:12:17 2017
@author: savit
"""
def sign(n):
return n//abs(n)
n,p,q,r=map(int,input().split())
A=list(map(int,input().split()))
Q=q
P=p
R=r
if(p<=0 and q<=0 and r<=0):
print((p+q+r)*min(A))
elif(p>=0 and q>=0 and r>=0):
print((p+q+r)*max(A))
elif(p*r>=0 and p<0):
b=[]
max1=-9999999999999999999999999999999
for i in range(n):
b.append((A[i],i))
b.sort()
mini=b[0][1]
temp=mini
temp2=A[mini]
tempb=0
while(temp>=0):
temp2=max(A[temp],temp2)
while(b[tempb][1]>temp):
tempb+=1
max1=max(p*b[tempb][0]+q*temp2 + r*A[mini],max1)
temp-=1
temp2=A[mini]
tempb=0
temp=mini
while(temp<=n-1):
temp2=max(A[temp],temp2)
while(b[tempb][1]<temp):
tempb+=1
max1=max(r*b[tempb][0]+q*temp2 + p*A[mini],max1)
temp+=1
print(max1)
elif(p*r>=0 and p>=0):
b=[]
max1=-9999999999999999999999999999999
for i in range(n):
b.append((A[i],i))
b.sort()
mini=b[n-1][1]
temp=mini
temp2=A[mini]
tempb=n-1
while(temp>=0):
temp2=min(A[temp],temp2)
while(b[tempb][1]>temp):
tempb-=1
max1=max(p*b[tempb][0]+q*temp2 + r*A[mini],max1)
temp-=1
temp2=A[mini]
tempb=n-1
temp=mini
while(temp<=n-1):
temp2=min(A[temp],temp2)
while(b[tempb][1]<temp):
tempb-=1
max1=max(r*b[tempb][0]+q*temp2 + p*A[mini],max1)
#print(b[tempb][1],A.index(temp2),mini)
temp+=1
print(max1)
elif(r>=0):
b=[]
if(q>=0):
r+=q
else:
p+=q
for i in range(n):
b.append((A[i],i))
b.sort()
max1=-99999999999999999999999999999999
temp=0
temp2=A[0]
tempb=n-1
while(temp<=n-1):
temp2=min(temp2,A[temp])
while(b[tempb][1]<temp):
tempb-=1
max1=max(max1,p*temp2+r*b[tempb][0])
temp+=1
print(max1)
elif(r<0):
b=[]
if(q<=0):
r+=q
else:
p+=q
for i in range(n):
b.append((A[i],i))
b.sort()
max1=-9999999999999999999999999999
temp=0
temp2=A[0]
tempb=0
while(temp<=n-1):
temp2=max(temp2,A[temp])
while(b[tempb][1]<temp):
tempb+=1
max1=max(max1,p*temp2+r*b[tempb][0])
temp+=1
print(max1)
```
|
instruction
| 0
| 3,875
| 2
| 7,750
|
Yes
|
output
| 1
| 3,875
| 2
| 7,751
|
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
Professor Dumbledore is helping Harry destroy the Horcruxes. He went to Gaunt Shack as he suspected a Horcrux to be present there. He saw Marvolo Gaunt's Ring and identified it as a Horcrux. Although he destroyed it, he is still affected by its curse. Professor Snape is helping Dumbledore remove the curse. For this, he wants to give Dumbledore exactly x drops of the potion he made.
Value of x is calculated as maximum of p·ai + q·aj + r·ak for given p, q, r and array a1, a2, ... an such that 1 ≤ i ≤ j ≤ k ≤ n. Help Snape find the value of x. Do note that the value of x may be negative.
Input
First line of input contains 4 integers n, p, q, r ( - 109 ≤ p, q, r ≤ 109, 1 ≤ n ≤ 105).
Next line of input contains n space separated integers a1, a2, ... an ( - 109 ≤ ai ≤ 109).
Output
Output a single integer the maximum value of p·ai + q·aj + r·ak that can be obtained provided 1 ≤ i ≤ j ≤ k ≤ n.
Examples
Input
5 1 2 3
1 2 3 4 5
Output
30
Input
5 1 2 -3
-1 -2 -3 -4 -5
Output
12
Note
In the first sample case, we can take i = j = k = 5, thus making the answer as 1·5 + 2·5 + 3·5 = 30.
In second sample case, selecting i = j = 1 and k = 5 gives the answer 12.
Submitted Solution:
```
n,p,q,r=map(int,input().split())
a=list(map(int,input().split()))
INF=10**10
dp=[[-INF]*3 for i in range(n)]
dp[0]=[p*a[0],(p+q)*a[0],(p+q+r)*a[0]]
for i in range(1,n):
dp[i][0]=max(dp[i-1][0],p*a[i])
dp[i][1]=max(dp[i-1][1],dp[i][0]+q*a[i])
dp[i][2]=max(dp[i-1][2],dp[i][1]+r*a[i])
print(dp[n-1][2])
```
|
instruction
| 0
| 3,876
| 2
| 7,752
|
Yes
|
output
| 1
| 3,876
| 2
| 7,753
|
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
Professor Dumbledore is helping Harry destroy the Horcruxes. He went to Gaunt Shack as he suspected a Horcrux to be present there. He saw Marvolo Gaunt's Ring and identified it as a Horcrux. Although he destroyed it, he is still affected by its curse. Professor Snape is helping Dumbledore remove the curse. For this, he wants to give Dumbledore exactly x drops of the potion he made.
Value of x is calculated as maximum of p·ai + q·aj + r·ak for given p, q, r and array a1, a2, ... an such that 1 ≤ i ≤ j ≤ k ≤ n. Help Snape find the value of x. Do note that the value of x may be negative.
Input
First line of input contains 4 integers n, p, q, r ( - 109 ≤ p, q, r ≤ 109, 1 ≤ n ≤ 105).
Next line of input contains n space separated integers a1, a2, ... an ( - 109 ≤ ai ≤ 109).
Output
Output a single integer the maximum value of p·ai + q·aj + r·ak that can be obtained provided 1 ≤ i ≤ j ≤ k ≤ n.
Examples
Input
5 1 2 3
1 2 3 4 5
Output
30
Input
5 1 2 -3
-1 -2 -3 -4 -5
Output
12
Note
In the first sample case, we can take i = j = k = 5, thus making the answer as 1·5 + 2·5 + 3·5 = 30.
In second sample case, selecting i = j = 1 and k = 5 gives the answer 12.
Submitted Solution:
```
cin=lambda:map(int,input().split())
n,p,q,r=cin()
A=cin()
tp,tq,tr=-1e20,-1e20,-1e20
for a in A:
tp=max(tp,p*a)
tq=max(tq,tp+q*a)
tr=max(tr,tq+r*a)
print(tr)
```
|
instruction
| 0
| 3,877
| 2
| 7,754
|
Yes
|
output
| 1
| 3,877
| 2
| 7,755
|
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
Professor Dumbledore is helping Harry destroy the Horcruxes. He went to Gaunt Shack as he suspected a Horcrux to be present there. He saw Marvolo Gaunt's Ring and identified it as a Horcrux. Although he destroyed it, he is still affected by its curse. Professor Snape is helping Dumbledore remove the curse. For this, he wants to give Dumbledore exactly x drops of the potion he made.
Value of x is calculated as maximum of p·ai + q·aj + r·ak for given p, q, r and array a1, a2, ... an such that 1 ≤ i ≤ j ≤ k ≤ n. Help Snape find the value of x. Do note that the value of x may be negative.
Input
First line of input contains 4 integers n, p, q, r ( - 109 ≤ p, q, r ≤ 109, 1 ≤ n ≤ 105).
Next line of input contains n space separated integers a1, a2, ... an ( - 109 ≤ ai ≤ 109).
Output
Output a single integer the maximum value of p·ai + q·aj + r·ak that can be obtained provided 1 ≤ i ≤ j ≤ k ≤ n.
Examples
Input
5 1 2 3
1 2 3 4 5
Output
30
Input
5 1 2 -3
-1 -2 -3 -4 -5
Output
12
Note
In the first sample case, we can take i = j = k = 5, thus making the answer as 1·5 + 2·5 + 3·5 = 30.
In second sample case, selecting i = j = 1 and k = 5 gives the answer 12.
Submitted Solution:
```
_ , x, y, z = map(int, input().split())
a = list(map(int, input().split()))
def ans(x, y, z, a):
all_neg = True
for e in a:
if e >= 0:
all_neg = False
break
def helper(x):
if x == 0:
return 0
if x > 0:
if all_neg:
return x * max(a)
else:
return x * max(a)
if x < 0:
if all_neg:
return x * min(a)
else:
return x * min(a)
#print(helper(x), helper(y), helper(z))
return helper(x) + helper(y) + helper(z)
print(ans(x,y,z,a))
```
|
instruction
| 0
| 3,878
| 2
| 7,756
|
No
|
output
| 1
| 3,878
| 2
| 7,757
|
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
Professor Dumbledore is helping Harry destroy the Horcruxes. He went to Gaunt Shack as he suspected a Horcrux to be present there. He saw Marvolo Gaunt's Ring and identified it as a Horcrux. Although he destroyed it, he is still affected by its curse. Professor Snape is helping Dumbledore remove the curse. For this, he wants to give Dumbledore exactly x drops of the potion he made.
Value of x is calculated as maximum of p·ai + q·aj + r·ak for given p, q, r and array a1, a2, ... an such that 1 ≤ i ≤ j ≤ k ≤ n. Help Snape find the value of x. Do note that the value of x may be negative.
Input
First line of input contains 4 integers n, p, q, r ( - 109 ≤ p, q, r ≤ 109, 1 ≤ n ≤ 105).
Next line of input contains n space separated integers a1, a2, ... an ( - 109 ≤ ai ≤ 109).
Output
Output a single integer the maximum value of p·ai + q·aj + r·ak that can be obtained provided 1 ≤ i ≤ j ≤ k ≤ n.
Examples
Input
5 1 2 3
1 2 3 4 5
Output
30
Input
5 1 2 -3
-1 -2 -3 -4 -5
Output
12
Note
In the first sample case, we can take i = j = k = 5, thus making the answer as 1·5 + 2·5 + 3·5 = 30.
In second sample case, selecting i = j = 1 and k = 5 gives the answer 12.
Submitted Solution:
```
import sys
initial_inp = []
inp = []
n = input().split()
count = int(n[0],10)
p = int(n[1],10)
q = int(n[2],10)
r = int(n[3],10)
arrString = input().split()
arr = count * [None]
for i in range(0,count):
arr[i] = int(arrString[i],10)
print(arr)
def maximum(a,b):
if a < b:
return b
else:
return a
#find prefix max
pmax = [1] * count
pmax[0] = arr[0] * p
print(arr[0],pmax[0])
print(pmax[0])
for i in range(1,count):
pmax[i] = maximum(pmax[i-1],(p*arr[i]))
print(pmax)
#find suffix max
smax = [1] * count
smax[count-1] = arr[count-1]*r
for i in range(count-2,-1,-1):
smax[i]=maximum(smax[i+1],(r*arr[i]))
print(smax)
#to find best position for q multiplier
ans = -sys.maxsize - 1
for i in range(0,count):
ans = maximum((pmax[i]+(q*arr[i])+smax[i]),ans)
print(ans)
```
|
instruction
| 0
| 3,879
| 2
| 7,758
|
No
|
output
| 1
| 3,879
| 2
| 7,759
|
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
Professor Dumbledore is helping Harry destroy the Horcruxes. He went to Gaunt Shack as he suspected a Horcrux to be present there. He saw Marvolo Gaunt's Ring and identified it as a Horcrux. Although he destroyed it, he is still affected by its curse. Professor Snape is helping Dumbledore remove the curse. For this, he wants to give Dumbledore exactly x drops of the potion he made.
Value of x is calculated as maximum of p·ai + q·aj + r·ak for given p, q, r and array a1, a2, ... an such that 1 ≤ i ≤ j ≤ k ≤ n. Help Snape find the value of x. Do note that the value of x may be negative.
Input
First line of input contains 4 integers n, p, q, r ( - 109 ≤ p, q, r ≤ 109, 1 ≤ n ≤ 105).
Next line of input contains n space separated integers a1, a2, ... an ( - 109 ≤ ai ≤ 109).
Output
Output a single integer the maximum value of p·ai + q·aj + r·ak that can be obtained provided 1 ≤ i ≤ j ≤ k ≤ n.
Examples
Input
5 1 2 3
1 2 3 4 5
Output
30
Input
5 1 2 -3
-1 -2 -3 -4 -5
Output
12
Note
In the first sample case, we can take i = j = k = 5, thus making the answer as 1·5 + 2·5 + 3·5 = 30.
In second sample case, selecting i = j = 1 and k = 5 gives the answer 12.
Submitted Solution:
```
n, p, q, r = map(int, input().split())
a = list(map(int, input().split()))
def findmx(a, h):
mxi = 0
#print(len(a))
for i in range(len(a)):
if (a[mxi] * h <= a[i] * h):
mxi = i
return mxi
##a1 = [i * p for i in a]
##a2 = [i * q for i in a]
##a3 = [i * r for i in a]
##
l1 = findmx(a, r)
l2 = findmx(a[0:l1 + 1], q)
l3 = findmx(a[0:l2 + 1], p)
##print(l3, l2, l1)
##print(a1)
##print(a2)
##print(a3)
l = p * a[l3] + q * a[l2] + r * a[l1]
##print()
h2 = findmx(a, q)
h1 = findmx(a[h2::], r) + h2
h3 = findmx(a[0:h2 + 1], p)
#print(h3, h2, h1)
h = p * a[h3] + q * a[h2] + r * a[h1]
##print()
##
##b = []
##for i in range(0, n):
## for j in range(0, i + 1):
## for k in range(0, j + 1):
## b.append([k, j, i, a1[k], a2[j], a3[i], a1[k] + a2[j] + a3[i]])
##print(*b, sep = "\n")
##
y3 = findmx(a, p)
y2 = findmx(a[y3::], q) + y3
y1 = findmx(a[y2::], r) + y2
#print(y3, y2, y1)
y = p * a[y3] + q * a[y2] + r * a[y1]
#print(l, h, y)
print(max(l, h, y))
```
|
instruction
| 0
| 3,880
| 2
| 7,760
|
No
|
output
| 1
| 3,880
| 2
| 7,761
|
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
Professor Dumbledore is helping Harry destroy the Horcruxes. He went to Gaunt Shack as he suspected a Horcrux to be present there. He saw Marvolo Gaunt's Ring and identified it as a Horcrux. Although he destroyed it, he is still affected by its curse. Professor Snape is helping Dumbledore remove the curse. For this, he wants to give Dumbledore exactly x drops of the potion he made.
Value of x is calculated as maximum of p·ai + q·aj + r·ak for given p, q, r and array a1, a2, ... an such that 1 ≤ i ≤ j ≤ k ≤ n. Help Snape find the value of x. Do note that the value of x may be negative.
Input
First line of input contains 4 integers n, p, q, r ( - 109 ≤ p, q, r ≤ 109, 1 ≤ n ≤ 105).
Next line of input contains n space separated integers a1, a2, ... an ( - 109 ≤ ai ≤ 109).
Output
Output a single integer the maximum value of p·ai + q·aj + r·ak that can be obtained provided 1 ≤ i ≤ j ≤ k ≤ n.
Examples
Input
5 1 2 3
1 2 3 4 5
Output
30
Input
5 1 2 -3
-1 -2 -3 -4 -5
Output
12
Note
In the first sample case, we can take i = j = k = 5, thus making the answer as 1·5 + 2·5 + 3·5 = 30.
In second sample case, selecting i = j = 1 and k = 5 gives the answer 12.
Submitted Solution:
```
b, p, q, r=[5, 1, 2, -3]
n=[-1, -2, -3, -4, -5]
ans = float('-infinity')
for ai in n:
for aj in n:
for ak in n:
ans = max(ans, p*ai+q*aj+r*ak)
print(ans)
```
|
instruction
| 0
| 3,881
| 2
| 7,762
|
No
|
output
| 1
| 3,881
| 2
| 7,763
|
Provide tags and a correct Python 3 solution for this coding contest problem.
Vova is again playing some computer game, now an RPG. In the game Vova's character received a quest: to slay the fearsome monster called Modcrab.
After two hours of playing the game Vova has tracked the monster and analyzed its tactics. The Modcrab has h2 health points and an attack power of a2. Knowing that, Vova has decided to buy a lot of strong healing potions and to prepare for battle.
Vova's character has h1 health points and an attack power of a1. Also he has a large supply of healing potions, each of which increases his current amount of health points by c1 when Vova drinks a potion. All potions are identical to each other. It is guaranteed that c1 > a2.
The battle consists of multiple phases. In the beginning of each phase, Vova can either attack the monster (thus reducing its health by a1) or drink a healing potion (it increases Vova's health by c1; Vova's health can exceed h1). Then, if the battle is not over yet, the Modcrab attacks Vova, reducing his health by a2. The battle ends when Vova's (or Modcrab's) health drops to 0 or lower. It is possible that the battle ends in a middle of a phase after Vova's attack.
Of course, Vova wants to win the fight. But also he wants to do it as fast as possible. So he wants to make up a strategy that will allow him to win the fight after the minimum possible number of phases.
Help Vova to make up a strategy! You may assume that Vova never runs out of healing potions, and that he can always win.
Input
The first line contains three integers h1, a1, c1 (1 ≤ h1, a1 ≤ 100, 2 ≤ c1 ≤ 100) — Vova's health, Vova's attack power and the healing power of a potion.
The second line contains two integers h2, a2 (1 ≤ h2 ≤ 100, 1 ≤ a2 < c1) — the Modcrab's health and his attack power.
Output
In the first line print one integer n denoting the minimum number of phases required to win the battle.
Then print n lines. i-th line must be equal to HEAL if Vova drinks a potion in i-th phase, or STRIKE if he attacks the Modcrab.
The strategy must be valid: Vova's character must not be defeated before slaying the Modcrab, and the monster's health must be 0 or lower after Vova's last action.
If there are multiple optimal solutions, print any of them.
Examples
Input
10 6 100
17 5
Output
4
STRIKE
HEAL
STRIKE
STRIKE
Input
11 6 100
12 5
Output
2
STRIKE
STRIKE
Note
In the first example Vova's character must heal before or after his first attack. Otherwise his health will drop to zero in 2 phases while he needs 3 strikes to win.
In the second example no healing needed, two strikes are enough to get monster to zero health and win with 6 health left.
|
instruction
| 0
| 3,882
| 2
| 7,764
|
Tags: greedy, implementation
Correct Solution:
```
import unittest
from functools import lru_cache
import math
h1, a1, c1 = tuple(map(int, input().split()))
h2, a2 = tuple(map(int, input().split()))
num_of_moves_to_kill = int(math.ceil(h2 / a1))
health_loosed = a2 * (num_of_moves_to_kill - 1)
if health_loosed < h1:
print(num_of_moves_to_kill)
for i in range(num_of_moves_to_kill):
print("STRIKE")
else:
health_needed = health_loosed - h1
drinks = math.floor(health_needed / (c1 - a2)) + 1
print(num_of_moves_to_kill + drinks)
for i in range(drinks):
print("HEAL")
for i in range(num_of_moves_to_kill):
print("STRIKE")
# 50 10 10
# 100 5
```
|
output
| 1
| 3,882
| 2
| 7,765
|
Provide tags and a correct Python 3 solution for this coding contest problem.
Vova is again playing some computer game, now an RPG. In the game Vova's character received a quest: to slay the fearsome monster called Modcrab.
After two hours of playing the game Vova has tracked the monster and analyzed its tactics. The Modcrab has h2 health points and an attack power of a2. Knowing that, Vova has decided to buy a lot of strong healing potions and to prepare for battle.
Vova's character has h1 health points and an attack power of a1. Also he has a large supply of healing potions, each of which increases his current amount of health points by c1 when Vova drinks a potion. All potions are identical to each other. It is guaranteed that c1 > a2.
The battle consists of multiple phases. In the beginning of each phase, Vova can either attack the monster (thus reducing its health by a1) or drink a healing potion (it increases Vova's health by c1; Vova's health can exceed h1). Then, if the battle is not over yet, the Modcrab attacks Vova, reducing his health by a2. The battle ends when Vova's (or Modcrab's) health drops to 0 or lower. It is possible that the battle ends in a middle of a phase after Vova's attack.
Of course, Vova wants to win the fight. But also he wants to do it as fast as possible. So he wants to make up a strategy that will allow him to win the fight after the minimum possible number of phases.
Help Vova to make up a strategy! You may assume that Vova never runs out of healing potions, and that he can always win.
Input
The first line contains three integers h1, a1, c1 (1 ≤ h1, a1 ≤ 100, 2 ≤ c1 ≤ 100) — Vova's health, Vova's attack power and the healing power of a potion.
The second line contains two integers h2, a2 (1 ≤ h2 ≤ 100, 1 ≤ a2 < c1) — the Modcrab's health and his attack power.
Output
In the first line print one integer n denoting the minimum number of phases required to win the battle.
Then print n lines. i-th line must be equal to HEAL if Vova drinks a potion in i-th phase, or STRIKE if he attacks the Modcrab.
The strategy must be valid: Vova's character must not be defeated before slaying the Modcrab, and the monster's health must be 0 or lower after Vova's last action.
If there are multiple optimal solutions, print any of them.
Examples
Input
10 6 100
17 5
Output
4
STRIKE
HEAL
STRIKE
STRIKE
Input
11 6 100
12 5
Output
2
STRIKE
STRIKE
Note
In the first example Vova's character must heal before or after his first attack. Otherwise his health will drop to zero in 2 phases while he needs 3 strikes to win.
In the second example no healing needed, two strikes are enough to get monster to zero health and win with 6 health left.
|
instruction
| 0
| 3,883
| 2
| 7,766
|
Tags: greedy, implementation
Correct Solution:
```
import math
h = [0, 0]
a = [0, 0]
c = 0
h[0], a[0], c = map(int, input().strip().split())
h[1], a[1] = map(int, input().strip().split())
res = []
count = 0
while h[1] > 0:
if h[0] > a[1] or (h[0] <= a[1] and h[1] <= a[0]):
res.append("STRIKE")
h[1] -= a[0]
else:
res.append("HEAL")
h[0] += c
h[0] -= a[1]
count += 1
print(str(count))
for item in res:
print(item)
```
|
output
| 1
| 3,883
| 2
| 7,767
|
Provide tags and a correct Python 3 solution for this coding contest problem.
Vova is again playing some computer game, now an RPG. In the game Vova's character received a quest: to slay the fearsome monster called Modcrab.
After two hours of playing the game Vova has tracked the monster and analyzed its tactics. The Modcrab has h2 health points and an attack power of a2. Knowing that, Vova has decided to buy a lot of strong healing potions and to prepare for battle.
Vova's character has h1 health points and an attack power of a1. Also he has a large supply of healing potions, each of which increases his current amount of health points by c1 when Vova drinks a potion. All potions are identical to each other. It is guaranteed that c1 > a2.
The battle consists of multiple phases. In the beginning of each phase, Vova can either attack the monster (thus reducing its health by a1) or drink a healing potion (it increases Vova's health by c1; Vova's health can exceed h1). Then, if the battle is not over yet, the Modcrab attacks Vova, reducing his health by a2. The battle ends when Vova's (or Modcrab's) health drops to 0 or lower. It is possible that the battle ends in a middle of a phase after Vova's attack.
Of course, Vova wants to win the fight. But also he wants to do it as fast as possible. So he wants to make up a strategy that will allow him to win the fight after the minimum possible number of phases.
Help Vova to make up a strategy! You may assume that Vova never runs out of healing potions, and that he can always win.
Input
The first line contains three integers h1, a1, c1 (1 ≤ h1, a1 ≤ 100, 2 ≤ c1 ≤ 100) — Vova's health, Vova's attack power and the healing power of a potion.
The second line contains two integers h2, a2 (1 ≤ h2 ≤ 100, 1 ≤ a2 < c1) — the Modcrab's health and his attack power.
Output
In the first line print one integer n denoting the minimum number of phases required to win the battle.
Then print n lines. i-th line must be equal to HEAL if Vova drinks a potion in i-th phase, or STRIKE if he attacks the Modcrab.
The strategy must be valid: Vova's character must not be defeated before slaying the Modcrab, and the monster's health must be 0 or lower after Vova's last action.
If there are multiple optimal solutions, print any of them.
Examples
Input
10 6 100
17 5
Output
4
STRIKE
HEAL
STRIKE
STRIKE
Input
11 6 100
12 5
Output
2
STRIKE
STRIKE
Note
In the first example Vova's character must heal before or after his first attack. Otherwise his health will drop to zero in 2 phases while he needs 3 strikes to win.
In the second example no healing needed, two strikes are enough to get monster to zero health and win with 6 health left.
|
instruction
| 0
| 3,884
| 2
| 7,768
|
Tags: greedy, implementation
Correct Solution:
```
h1,a1,c1 = map(int,input().split())
h2,a2 = map(int,input().split())
l = []
while(h2 > 0):
if h1-a2 <= 0 and (h2-a1) > 0:
l.append("HEAL")
h1 = h1+c1
else:
l.append("STRIKE")
h2 = h2-a1
h1 = h1-a2
print(len(l))
for i in l:
print(i)
```
|
output
| 1
| 3,884
| 2
| 7,769
|
Provide tags and a correct Python 3 solution for this coding contest problem.
Vova is again playing some computer game, now an RPG. In the game Vova's character received a quest: to slay the fearsome monster called Modcrab.
After two hours of playing the game Vova has tracked the monster and analyzed its tactics. The Modcrab has h2 health points and an attack power of a2. Knowing that, Vova has decided to buy a lot of strong healing potions and to prepare for battle.
Vova's character has h1 health points and an attack power of a1. Also he has a large supply of healing potions, each of which increases his current amount of health points by c1 when Vova drinks a potion. All potions are identical to each other. It is guaranteed that c1 > a2.
The battle consists of multiple phases. In the beginning of each phase, Vova can either attack the monster (thus reducing its health by a1) or drink a healing potion (it increases Vova's health by c1; Vova's health can exceed h1). Then, if the battle is not over yet, the Modcrab attacks Vova, reducing his health by a2. The battle ends when Vova's (or Modcrab's) health drops to 0 or lower. It is possible that the battle ends in a middle of a phase after Vova's attack.
Of course, Vova wants to win the fight. But also he wants to do it as fast as possible. So he wants to make up a strategy that will allow him to win the fight after the minimum possible number of phases.
Help Vova to make up a strategy! You may assume that Vova never runs out of healing potions, and that he can always win.
Input
The first line contains three integers h1, a1, c1 (1 ≤ h1, a1 ≤ 100, 2 ≤ c1 ≤ 100) — Vova's health, Vova's attack power and the healing power of a potion.
The second line contains two integers h2, a2 (1 ≤ h2 ≤ 100, 1 ≤ a2 < c1) — the Modcrab's health and his attack power.
Output
In the first line print one integer n denoting the minimum number of phases required to win the battle.
Then print n lines. i-th line must be equal to HEAL if Vova drinks a potion in i-th phase, or STRIKE if he attacks the Modcrab.
The strategy must be valid: Vova's character must not be defeated before slaying the Modcrab, and the monster's health must be 0 or lower after Vova's last action.
If there are multiple optimal solutions, print any of them.
Examples
Input
10 6 100
17 5
Output
4
STRIKE
HEAL
STRIKE
STRIKE
Input
11 6 100
12 5
Output
2
STRIKE
STRIKE
Note
In the first example Vova's character must heal before or after his first attack. Otherwise his health will drop to zero in 2 phases while he needs 3 strikes to win.
In the second example no healing needed, two strikes are enough to get monster to zero health and win with 6 health left.
|
instruction
| 0
| 3,885
| 2
| 7,770
|
Tags: greedy, implementation
Correct Solution:
```
def main():
h1, a1, c = map(int, input().split())
h2, a2 = map(int, input().split())
out = []
while h2 > 0:
if a2 < h1 or a1 >= h2:
out.append('STRIKE')
h2 -= a1
h1 -= a2
else:
out.append('HEAL')
h1 += c
h1 -= a2
print(len(out))
for s in out:
print(s)
main()
```
|
output
| 1
| 3,885
| 2
| 7,771
|
Provide tags and a correct Python 3 solution for this coding contest problem.
Vova is again playing some computer game, now an RPG. In the game Vova's character received a quest: to slay the fearsome monster called Modcrab.
After two hours of playing the game Vova has tracked the monster and analyzed its tactics. The Modcrab has h2 health points and an attack power of a2. Knowing that, Vova has decided to buy a lot of strong healing potions and to prepare for battle.
Vova's character has h1 health points and an attack power of a1. Also he has a large supply of healing potions, each of which increases his current amount of health points by c1 when Vova drinks a potion. All potions are identical to each other. It is guaranteed that c1 > a2.
The battle consists of multiple phases. In the beginning of each phase, Vova can either attack the monster (thus reducing its health by a1) or drink a healing potion (it increases Vova's health by c1; Vova's health can exceed h1). Then, if the battle is not over yet, the Modcrab attacks Vova, reducing his health by a2. The battle ends when Vova's (or Modcrab's) health drops to 0 or lower. It is possible that the battle ends in a middle of a phase after Vova's attack.
Of course, Vova wants to win the fight. But also he wants to do it as fast as possible. So he wants to make up a strategy that will allow him to win the fight after the minimum possible number of phases.
Help Vova to make up a strategy! You may assume that Vova never runs out of healing potions, and that he can always win.
Input
The first line contains three integers h1, a1, c1 (1 ≤ h1, a1 ≤ 100, 2 ≤ c1 ≤ 100) — Vova's health, Vova's attack power and the healing power of a potion.
The second line contains two integers h2, a2 (1 ≤ h2 ≤ 100, 1 ≤ a2 < c1) — the Modcrab's health and his attack power.
Output
In the first line print one integer n denoting the minimum number of phases required to win the battle.
Then print n lines. i-th line must be equal to HEAL if Vova drinks a potion in i-th phase, or STRIKE if he attacks the Modcrab.
The strategy must be valid: Vova's character must not be defeated before slaying the Modcrab, and the monster's health must be 0 or lower after Vova's last action.
If there are multiple optimal solutions, print any of them.
Examples
Input
10 6 100
17 5
Output
4
STRIKE
HEAL
STRIKE
STRIKE
Input
11 6 100
12 5
Output
2
STRIKE
STRIKE
Note
In the first example Vova's character must heal before or after his first attack. Otherwise his health will drop to zero in 2 phases while he needs 3 strikes to win.
In the second example no healing needed, two strikes are enough to get monster to zero health and win with 6 health left.
|
instruction
| 0
| 3,886
| 2
| 7,772
|
Tags: greedy, implementation
Correct Solution:
```
life, attack, heal = map(int,input().split())
ml, ma = map(int,input().split())
ans=''
count=0
while ml>0:
if life <= ma and ml> attack:
life +=heal
ans+='HEAL\n'
else :
ml-=attack
ans+='STRIKE\n'
life-=ma
count+=1
ans=str(count)+"\n"+ans
print(ans)
```
|
output
| 1
| 3,886
| 2
| 7,773
|
Provide tags and a correct Python 3 solution for this coding contest problem.
Vova is again playing some computer game, now an RPG. In the game Vova's character received a quest: to slay the fearsome monster called Modcrab.
After two hours of playing the game Vova has tracked the monster and analyzed its tactics. The Modcrab has h2 health points and an attack power of a2. Knowing that, Vova has decided to buy a lot of strong healing potions and to prepare for battle.
Vova's character has h1 health points and an attack power of a1. Also he has a large supply of healing potions, each of which increases his current amount of health points by c1 when Vova drinks a potion. All potions are identical to each other. It is guaranteed that c1 > a2.
The battle consists of multiple phases. In the beginning of each phase, Vova can either attack the monster (thus reducing its health by a1) or drink a healing potion (it increases Vova's health by c1; Vova's health can exceed h1). Then, if the battle is not over yet, the Modcrab attacks Vova, reducing his health by a2. The battle ends when Vova's (or Modcrab's) health drops to 0 or lower. It is possible that the battle ends in a middle of a phase after Vova's attack.
Of course, Vova wants to win the fight. But also he wants to do it as fast as possible. So he wants to make up a strategy that will allow him to win the fight after the minimum possible number of phases.
Help Vova to make up a strategy! You may assume that Vova never runs out of healing potions, and that he can always win.
Input
The first line contains three integers h1, a1, c1 (1 ≤ h1, a1 ≤ 100, 2 ≤ c1 ≤ 100) — Vova's health, Vova's attack power and the healing power of a potion.
The second line contains two integers h2, a2 (1 ≤ h2 ≤ 100, 1 ≤ a2 < c1) — the Modcrab's health and his attack power.
Output
In the first line print one integer n denoting the minimum number of phases required to win the battle.
Then print n lines. i-th line must be equal to HEAL if Vova drinks a potion in i-th phase, or STRIKE if he attacks the Modcrab.
The strategy must be valid: Vova's character must not be defeated before slaying the Modcrab, and the monster's health must be 0 or lower after Vova's last action.
If there are multiple optimal solutions, print any of them.
Examples
Input
10 6 100
17 5
Output
4
STRIKE
HEAL
STRIKE
STRIKE
Input
11 6 100
12 5
Output
2
STRIKE
STRIKE
Note
In the first example Vova's character must heal before or after his first attack. Otherwise his health will drop to zero in 2 phases while he needs 3 strikes to win.
In the second example no healing needed, two strikes are enough to get monster to zero health and win with 6 health left.
|
instruction
| 0
| 3,887
| 2
| 7,774
|
Tags: greedy, implementation
Correct Solution:
```
h1,a1,c1 = map(int,input().split())
h2,a2 = map(int,input().split())
li = []
while 1:
if (h1-a2)>0 or (h2-a1)<=0:
h2-=a1
li.append("STRIKE")
else:
li.append("HEAL")
h1+=c1
if h2<=0:
break
h1-=a2
print(len(li))
for i in li:
print(i)
```
|
output
| 1
| 3,887
| 2
| 7,775
|
Provide tags and a correct Python 3 solution for this coding contest problem.
Vova is again playing some computer game, now an RPG. In the game Vova's character received a quest: to slay the fearsome monster called Modcrab.
After two hours of playing the game Vova has tracked the monster and analyzed its tactics. The Modcrab has h2 health points and an attack power of a2. Knowing that, Vova has decided to buy a lot of strong healing potions and to prepare for battle.
Vova's character has h1 health points and an attack power of a1. Also he has a large supply of healing potions, each of which increases his current amount of health points by c1 when Vova drinks a potion. All potions are identical to each other. It is guaranteed that c1 > a2.
The battle consists of multiple phases. In the beginning of each phase, Vova can either attack the monster (thus reducing its health by a1) or drink a healing potion (it increases Vova's health by c1; Vova's health can exceed h1). Then, if the battle is not over yet, the Modcrab attacks Vova, reducing his health by a2. The battle ends when Vova's (or Modcrab's) health drops to 0 or lower. It is possible that the battle ends in a middle of a phase after Vova's attack.
Of course, Vova wants to win the fight. But also he wants to do it as fast as possible. So he wants to make up a strategy that will allow him to win the fight after the minimum possible number of phases.
Help Vova to make up a strategy! You may assume that Vova never runs out of healing potions, and that he can always win.
Input
The first line contains three integers h1, a1, c1 (1 ≤ h1, a1 ≤ 100, 2 ≤ c1 ≤ 100) — Vova's health, Vova's attack power and the healing power of a potion.
The second line contains two integers h2, a2 (1 ≤ h2 ≤ 100, 1 ≤ a2 < c1) — the Modcrab's health and his attack power.
Output
In the first line print one integer n denoting the minimum number of phases required to win the battle.
Then print n lines. i-th line must be equal to HEAL if Vova drinks a potion in i-th phase, or STRIKE if he attacks the Modcrab.
The strategy must be valid: Vova's character must not be defeated before slaying the Modcrab, and the monster's health must be 0 or lower after Vova's last action.
If there are multiple optimal solutions, print any of them.
Examples
Input
10 6 100
17 5
Output
4
STRIKE
HEAL
STRIKE
STRIKE
Input
11 6 100
12 5
Output
2
STRIKE
STRIKE
Note
In the first example Vova's character must heal before or after his first attack. Otherwise his health will drop to zero in 2 phases while he needs 3 strikes to win.
In the second example no healing needed, two strikes are enough to get monster to zero health and win with 6 health left.
|
instruction
| 0
| 3,888
| 2
| 7,776
|
Tags: greedy, implementation
Correct Solution:
```
h1, a1, c = [int(i) for i in input().split()]
h2, a2 = [int(i) for i in input().split()]
y = (h2 + a1 - 1) // a1
x = max((a2 * (y - 1) - h1 + c - a2), 0) // (c - a2)
print(x + y)
for i in range(x):
print('HEAL')
for i in range(y):
print('STRIKE')
```
|
output
| 1
| 3,888
| 2
| 7,777
|
Provide tags and a correct Python 3 solution for this coding contest problem.
Vova is again playing some computer game, now an RPG. In the game Vova's character received a quest: to slay the fearsome monster called Modcrab.
After two hours of playing the game Vova has tracked the monster and analyzed its tactics. The Modcrab has h2 health points and an attack power of a2. Knowing that, Vova has decided to buy a lot of strong healing potions and to prepare for battle.
Vova's character has h1 health points and an attack power of a1. Also he has a large supply of healing potions, each of which increases his current amount of health points by c1 when Vova drinks a potion. All potions are identical to each other. It is guaranteed that c1 > a2.
The battle consists of multiple phases. In the beginning of each phase, Vova can either attack the monster (thus reducing its health by a1) or drink a healing potion (it increases Vova's health by c1; Vova's health can exceed h1). Then, if the battle is not over yet, the Modcrab attacks Vova, reducing his health by a2. The battle ends when Vova's (or Modcrab's) health drops to 0 or lower. It is possible that the battle ends in a middle of a phase after Vova's attack.
Of course, Vova wants to win the fight. But also he wants to do it as fast as possible. So he wants to make up a strategy that will allow him to win the fight after the minimum possible number of phases.
Help Vova to make up a strategy! You may assume that Vova never runs out of healing potions, and that he can always win.
Input
The first line contains three integers h1, a1, c1 (1 ≤ h1, a1 ≤ 100, 2 ≤ c1 ≤ 100) — Vova's health, Vova's attack power and the healing power of a potion.
The second line contains two integers h2, a2 (1 ≤ h2 ≤ 100, 1 ≤ a2 < c1) — the Modcrab's health and his attack power.
Output
In the first line print one integer n denoting the minimum number of phases required to win the battle.
Then print n lines. i-th line must be equal to HEAL if Vova drinks a potion in i-th phase, or STRIKE if he attacks the Modcrab.
The strategy must be valid: Vova's character must not be defeated before slaying the Modcrab, and the monster's health must be 0 or lower after Vova's last action.
If there are multiple optimal solutions, print any of them.
Examples
Input
10 6 100
17 5
Output
4
STRIKE
HEAL
STRIKE
STRIKE
Input
11 6 100
12 5
Output
2
STRIKE
STRIKE
Note
In the first example Vova's character must heal before or after his first attack. Otherwise his health will drop to zero in 2 phases while he needs 3 strikes to win.
In the second example no healing needed, two strikes are enough to get monster to zero health and win with 6 health left.
|
instruction
| 0
| 3,889
| 2
| 7,778
|
Tags: greedy, implementation
Correct Solution:
```
h1, a1, c1 = map(int, input().split())
h2, a2 = map(int, input().split())
data = []
while h2 > 0:
# Attack
if h1 > a2 or a1 >= h2:
h2 -= a1
data.append("STRIKE")
# Heal
else:
h1 += c1
data.append("HEAL")
h1 -= a2
print(len(data))
for item in data:
print(item)
```
|
output
| 1
| 3,889
| 2
| 7,779
|
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
Vova is again playing some computer game, now an RPG. In the game Vova's character received a quest: to slay the fearsome monster called Modcrab.
After two hours of playing the game Vova has tracked the monster and analyzed its tactics. The Modcrab has h2 health points and an attack power of a2. Knowing that, Vova has decided to buy a lot of strong healing potions and to prepare for battle.
Vova's character has h1 health points and an attack power of a1. Also he has a large supply of healing potions, each of which increases his current amount of health points by c1 when Vova drinks a potion. All potions are identical to each other. It is guaranteed that c1 > a2.
The battle consists of multiple phases. In the beginning of each phase, Vova can either attack the monster (thus reducing its health by a1) or drink a healing potion (it increases Vova's health by c1; Vova's health can exceed h1). Then, if the battle is not over yet, the Modcrab attacks Vova, reducing his health by a2. The battle ends when Vova's (or Modcrab's) health drops to 0 or lower. It is possible that the battle ends in a middle of a phase after Vova's attack.
Of course, Vova wants to win the fight. But also he wants to do it as fast as possible. So he wants to make up a strategy that will allow him to win the fight after the minimum possible number of phases.
Help Vova to make up a strategy! You may assume that Vova never runs out of healing potions, and that he can always win.
Input
The first line contains three integers h1, a1, c1 (1 ≤ h1, a1 ≤ 100, 2 ≤ c1 ≤ 100) — Vova's health, Vova's attack power and the healing power of a potion.
The second line contains two integers h2, a2 (1 ≤ h2 ≤ 100, 1 ≤ a2 < c1) — the Modcrab's health and his attack power.
Output
In the first line print one integer n denoting the minimum number of phases required to win the battle.
Then print n lines. i-th line must be equal to HEAL if Vova drinks a potion in i-th phase, or STRIKE if he attacks the Modcrab.
The strategy must be valid: Vova's character must not be defeated before slaying the Modcrab, and the monster's health must be 0 or lower after Vova's last action.
If there are multiple optimal solutions, print any of them.
Examples
Input
10 6 100
17 5
Output
4
STRIKE
HEAL
STRIKE
STRIKE
Input
11 6 100
12 5
Output
2
STRIKE
STRIKE
Note
In the first example Vova's character must heal before or after his first attack. Otherwise his health will drop to zero in 2 phases while he needs 3 strikes to win.
In the second example no healing needed, two strikes are enough to get monster to zero health and win with 6 health left.
Submitted Solution:
```
h1, a1, c1 = [int(i) for i in input().split()]
h2, a2 = [int(i) for i in input().split()]
k = (h2 + a1 - 1) // a1
#print(k)
e = []
while k > 0:
#print(k, h1, a2)
if k == 1:
e.append("STRIKE")
break
if h1 <= a2:
e.append("HEAL")
h1 += c1
else:
e.append("STRIKE")
k -= 1
h1 -= a2
print(len(e))
for el in e:
print(el)
```
|
instruction
| 0
| 3,890
| 2
| 7,780
|
Yes
|
output
| 1
| 3,890
| 2
| 7,781
|
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
Vova is again playing some computer game, now an RPG. In the game Vova's character received a quest: to slay the fearsome monster called Modcrab.
After two hours of playing the game Vova has tracked the monster and analyzed its tactics. The Modcrab has h2 health points and an attack power of a2. Knowing that, Vova has decided to buy a lot of strong healing potions and to prepare for battle.
Vova's character has h1 health points and an attack power of a1. Also he has a large supply of healing potions, each of which increases his current amount of health points by c1 when Vova drinks a potion. All potions are identical to each other. It is guaranteed that c1 > a2.
The battle consists of multiple phases. In the beginning of each phase, Vova can either attack the monster (thus reducing its health by a1) or drink a healing potion (it increases Vova's health by c1; Vova's health can exceed h1). Then, if the battle is not over yet, the Modcrab attacks Vova, reducing his health by a2. The battle ends when Vova's (or Modcrab's) health drops to 0 or lower. It is possible that the battle ends in a middle of a phase after Vova's attack.
Of course, Vova wants to win the fight. But also he wants to do it as fast as possible. So he wants to make up a strategy that will allow him to win the fight after the minimum possible number of phases.
Help Vova to make up a strategy! You may assume that Vova never runs out of healing potions, and that he can always win.
Input
The first line contains three integers h1, a1, c1 (1 ≤ h1, a1 ≤ 100, 2 ≤ c1 ≤ 100) — Vova's health, Vova's attack power and the healing power of a potion.
The second line contains two integers h2, a2 (1 ≤ h2 ≤ 100, 1 ≤ a2 < c1) — the Modcrab's health and his attack power.
Output
In the first line print one integer n denoting the minimum number of phases required to win the battle.
Then print n lines. i-th line must be equal to HEAL if Vova drinks a potion in i-th phase, or STRIKE if he attacks the Modcrab.
The strategy must be valid: Vova's character must not be defeated before slaying the Modcrab, and the monster's health must be 0 or lower after Vova's last action.
If there are multiple optimal solutions, print any of them.
Examples
Input
10 6 100
17 5
Output
4
STRIKE
HEAL
STRIKE
STRIKE
Input
11 6 100
12 5
Output
2
STRIKE
STRIKE
Note
In the first example Vova's character must heal before or after his first attack. Otherwise his health will drop to zero in 2 phases while he needs 3 strikes to win.
In the second example no healing needed, two strikes are enough to get monster to zero health and win with 6 health left.
Submitted Solution:
```
l=list(map(int,input().split()))
l1=list(map(int,input().split()))
k=0
S=''
while l1[0]>0 :
k+=1
if l1[0]-l[1]<=0 :
S+="STRIKE"+"\n"
break
if l[0]-l1[1]<=0 :
S+="HEAL"+"\n"
l[0]=l[0]+l[2]
else :
l1[0]=l1[0]-l[1]
S+="STRIKE"+"\n"
l[0]-=l1[1]
print(k)
print(S)
```
|
instruction
| 0
| 3,891
| 2
| 7,782
|
Yes
|
output
| 1
| 3,891
| 2
| 7,783
|
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
Vova is again playing some computer game, now an RPG. In the game Vova's character received a quest: to slay the fearsome monster called Modcrab.
After two hours of playing the game Vova has tracked the monster and analyzed its tactics. The Modcrab has h2 health points and an attack power of a2. Knowing that, Vova has decided to buy a lot of strong healing potions and to prepare for battle.
Vova's character has h1 health points and an attack power of a1. Also he has a large supply of healing potions, each of which increases his current amount of health points by c1 when Vova drinks a potion. All potions are identical to each other. It is guaranteed that c1 > a2.
The battle consists of multiple phases. In the beginning of each phase, Vova can either attack the monster (thus reducing its health by a1) or drink a healing potion (it increases Vova's health by c1; Vova's health can exceed h1). Then, if the battle is not over yet, the Modcrab attacks Vova, reducing his health by a2. The battle ends when Vova's (or Modcrab's) health drops to 0 or lower. It is possible that the battle ends in a middle of a phase after Vova's attack.
Of course, Vova wants to win the fight. But also he wants to do it as fast as possible. So he wants to make up a strategy that will allow him to win the fight after the minimum possible number of phases.
Help Vova to make up a strategy! You may assume that Vova never runs out of healing potions, and that he can always win.
Input
The first line contains three integers h1, a1, c1 (1 ≤ h1, a1 ≤ 100, 2 ≤ c1 ≤ 100) — Vova's health, Vova's attack power and the healing power of a potion.
The second line contains two integers h2, a2 (1 ≤ h2 ≤ 100, 1 ≤ a2 < c1) — the Modcrab's health and his attack power.
Output
In the first line print one integer n denoting the minimum number of phases required to win the battle.
Then print n lines. i-th line must be equal to HEAL if Vova drinks a potion in i-th phase, or STRIKE if he attacks the Modcrab.
The strategy must be valid: Vova's character must not be defeated before slaying the Modcrab, and the monster's health must be 0 or lower after Vova's last action.
If there are multiple optimal solutions, print any of them.
Examples
Input
10 6 100
17 5
Output
4
STRIKE
HEAL
STRIKE
STRIKE
Input
11 6 100
12 5
Output
2
STRIKE
STRIKE
Note
In the first example Vova's character must heal before or after his first attack. Otherwise his health will drop to zero in 2 phases while he needs 3 strikes to win.
In the second example no healing needed, two strikes are enough to get monster to zero health and win with 6 health left.
Submitted Solution:
```
R=lambda:map(int,input().split())
h,a,c=R()
g,b=R()
l=[]
while g>0:
while h<=b and g>a:
l.append('HEAL')
h+=c-b
while g>0 and (h>b or g<=a):
l.append('STRIKE')
g-=a
h-=b
print(len(l),*l,sep='\n')
```
|
instruction
| 0
| 3,892
| 2
| 7,784
|
Yes
|
output
| 1
| 3,892
| 2
| 7,785
|
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
Vova is again playing some computer game, now an RPG. In the game Vova's character received a quest: to slay the fearsome monster called Modcrab.
After two hours of playing the game Vova has tracked the monster and analyzed its tactics. The Modcrab has h2 health points and an attack power of a2. Knowing that, Vova has decided to buy a lot of strong healing potions and to prepare for battle.
Vova's character has h1 health points and an attack power of a1. Also he has a large supply of healing potions, each of which increases his current amount of health points by c1 when Vova drinks a potion. All potions are identical to each other. It is guaranteed that c1 > a2.
The battle consists of multiple phases. In the beginning of each phase, Vova can either attack the monster (thus reducing its health by a1) or drink a healing potion (it increases Vova's health by c1; Vova's health can exceed h1). Then, if the battle is not over yet, the Modcrab attacks Vova, reducing his health by a2. The battle ends when Vova's (or Modcrab's) health drops to 0 or lower. It is possible that the battle ends in a middle of a phase after Vova's attack.
Of course, Vova wants to win the fight. But also he wants to do it as fast as possible. So he wants to make up a strategy that will allow him to win the fight after the minimum possible number of phases.
Help Vova to make up a strategy! You may assume that Vova never runs out of healing potions, and that he can always win.
Input
The first line contains three integers h1, a1, c1 (1 ≤ h1, a1 ≤ 100, 2 ≤ c1 ≤ 100) — Vova's health, Vova's attack power and the healing power of a potion.
The second line contains two integers h2, a2 (1 ≤ h2 ≤ 100, 1 ≤ a2 < c1) — the Modcrab's health and his attack power.
Output
In the first line print one integer n denoting the minimum number of phases required to win the battle.
Then print n lines. i-th line must be equal to HEAL if Vova drinks a potion in i-th phase, or STRIKE if he attacks the Modcrab.
The strategy must be valid: Vova's character must not be defeated before slaying the Modcrab, and the monster's health must be 0 or lower after Vova's last action.
If there are multiple optimal solutions, print any of them.
Examples
Input
10 6 100
17 5
Output
4
STRIKE
HEAL
STRIKE
STRIKE
Input
11 6 100
12 5
Output
2
STRIKE
STRIKE
Note
In the first example Vova's character must heal before or after his first attack. Otherwise his health will drop to zero in 2 phases while he needs 3 strikes to win.
In the second example no healing needed, two strikes are enough to get monster to zero health and win with 6 health left.
Submitted Solution:
```
a = list(map(int,input().split()))
b = list(map(int,input().split()))
t = []
while b[0]>0:
if b[1]>=a[0] and a[1]<b[0]:
a[0]= a[0]+a[2]
t.append("HEAL")
else:
b[0]=b[0]-a[1]
t.append("STRIKE")
a[0]=a[0]-b[1]
print(len(t))
for x in t:
print(x)
```
|
instruction
| 0
| 3,893
| 2
| 7,786
|
Yes
|
output
| 1
| 3,893
| 2
| 7,787
|
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
Vova is again playing some computer game, now an RPG. In the game Vova's character received a quest: to slay the fearsome monster called Modcrab.
After two hours of playing the game Vova has tracked the monster and analyzed its tactics. The Modcrab has h2 health points and an attack power of a2. Knowing that, Vova has decided to buy a lot of strong healing potions and to prepare for battle.
Vova's character has h1 health points and an attack power of a1. Also he has a large supply of healing potions, each of which increases his current amount of health points by c1 when Vova drinks a potion. All potions are identical to each other. It is guaranteed that c1 > a2.
The battle consists of multiple phases. In the beginning of each phase, Vova can either attack the monster (thus reducing its health by a1) or drink a healing potion (it increases Vova's health by c1; Vova's health can exceed h1). Then, if the battle is not over yet, the Modcrab attacks Vova, reducing his health by a2. The battle ends when Vova's (or Modcrab's) health drops to 0 or lower. It is possible that the battle ends in a middle of a phase after Vova's attack.
Of course, Vova wants to win the fight. But also he wants to do it as fast as possible. So he wants to make up a strategy that will allow him to win the fight after the minimum possible number of phases.
Help Vova to make up a strategy! You may assume that Vova never runs out of healing potions, and that he can always win.
Input
The first line contains three integers h1, a1, c1 (1 ≤ h1, a1 ≤ 100, 2 ≤ c1 ≤ 100) — Vova's health, Vova's attack power and the healing power of a potion.
The second line contains two integers h2, a2 (1 ≤ h2 ≤ 100, 1 ≤ a2 < c1) — the Modcrab's health and his attack power.
Output
In the first line print one integer n denoting the minimum number of phases required to win the battle.
Then print n lines. i-th line must be equal to HEAL if Vova drinks a potion in i-th phase, or STRIKE if he attacks the Modcrab.
The strategy must be valid: Vova's character must not be defeated before slaying the Modcrab, and the monster's health must be 0 or lower after Vova's last action.
If there are multiple optimal solutions, print any of them.
Examples
Input
10 6 100
17 5
Output
4
STRIKE
HEAL
STRIKE
STRIKE
Input
11 6 100
12 5
Output
2
STRIKE
STRIKE
Note
In the first example Vova's character must heal before or after his first attack. Otherwise his health will drop to zero in 2 phases while he needs 3 strikes to win.
In the second example no healing needed, two strikes are enough to get monster to zero health and win with 6 health left.
Submitted Solution:
```
h1,a1,c1 = map(int, input().split()) # xiaohuang's property
h2,a2 = map(int, input().split()) # monster's property
h1_remain = h1
h2_remain = h2
record_list = []
while h2_remain >= 0:
if a2 >= h1_remain:
#print("HEAL")
record_list.append("HEAL")
h1_remain += c1
else:
#print("STRIKE")
record_list.append("STRIKE")
h2_remain -= a1
h1_remain -= a2
print(len(record_list))
for i in record_list:
print(i)
```
|
instruction
| 0
| 3,894
| 2
| 7,788
|
No
|
output
| 1
| 3,894
| 2
| 7,789
|
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
Vova is again playing some computer game, now an RPG. In the game Vova's character received a quest: to slay the fearsome monster called Modcrab.
After two hours of playing the game Vova has tracked the monster and analyzed its tactics. The Modcrab has h2 health points and an attack power of a2. Knowing that, Vova has decided to buy a lot of strong healing potions and to prepare for battle.
Vova's character has h1 health points and an attack power of a1. Also he has a large supply of healing potions, each of which increases his current amount of health points by c1 when Vova drinks a potion. All potions are identical to each other. It is guaranteed that c1 > a2.
The battle consists of multiple phases. In the beginning of each phase, Vova can either attack the monster (thus reducing its health by a1) or drink a healing potion (it increases Vova's health by c1; Vova's health can exceed h1). Then, if the battle is not over yet, the Modcrab attacks Vova, reducing his health by a2. The battle ends when Vova's (or Modcrab's) health drops to 0 or lower. It is possible that the battle ends in a middle of a phase after Vova's attack.
Of course, Vova wants to win the fight. But also he wants to do it as fast as possible. So he wants to make up a strategy that will allow him to win the fight after the minimum possible number of phases.
Help Vova to make up a strategy! You may assume that Vova never runs out of healing potions, and that he can always win.
Input
The first line contains three integers h1, a1, c1 (1 ≤ h1, a1 ≤ 100, 2 ≤ c1 ≤ 100) — Vova's health, Vova's attack power and the healing power of a potion.
The second line contains two integers h2, a2 (1 ≤ h2 ≤ 100, 1 ≤ a2 < c1) — the Modcrab's health and his attack power.
Output
In the first line print one integer n denoting the minimum number of phases required to win the battle.
Then print n lines. i-th line must be equal to HEAL if Vova drinks a potion in i-th phase, or STRIKE if he attacks the Modcrab.
The strategy must be valid: Vova's character must not be defeated before slaying the Modcrab, and the monster's health must be 0 or lower after Vova's last action.
If there are multiple optimal solutions, print any of them.
Examples
Input
10 6 100
17 5
Output
4
STRIKE
HEAL
STRIKE
STRIKE
Input
11 6 100
12 5
Output
2
STRIKE
STRIKE
Note
In the first example Vova's character must heal before or after his first attack. Otherwise his health will drop to zero in 2 phases while he needs 3 strikes to win.
In the second example no healing needed, two strikes are enough to get monster to zero health and win with 6 health left.
Submitted Solution:
```
life, attack, heal = map(int,input().split())
ml, ma = map(int,input().split())
ans=''
count=0
while ml>0:
if life <= ma :
life +=heal
ans+='HEAl\n'
else :
ml-=attack
ans+='STRIKE\n'
life-=ma
count+=1
ans=str(count)+"\n"+ans
print(ans)
```
|
instruction
| 0
| 3,895
| 2
| 7,790
|
No
|
output
| 1
| 3,895
| 2
| 7,791
|
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
Vova is again playing some computer game, now an RPG. In the game Vova's character received a quest: to slay the fearsome monster called Modcrab.
After two hours of playing the game Vova has tracked the monster and analyzed its tactics. The Modcrab has h2 health points and an attack power of a2. Knowing that, Vova has decided to buy a lot of strong healing potions and to prepare for battle.
Vova's character has h1 health points and an attack power of a1. Also he has a large supply of healing potions, each of which increases his current amount of health points by c1 when Vova drinks a potion. All potions are identical to each other. It is guaranteed that c1 > a2.
The battle consists of multiple phases. In the beginning of each phase, Vova can either attack the monster (thus reducing its health by a1) or drink a healing potion (it increases Vova's health by c1; Vova's health can exceed h1). Then, if the battle is not over yet, the Modcrab attacks Vova, reducing his health by a2. The battle ends when Vova's (or Modcrab's) health drops to 0 or lower. It is possible that the battle ends in a middle of a phase after Vova's attack.
Of course, Vova wants to win the fight. But also he wants to do it as fast as possible. So he wants to make up a strategy that will allow him to win the fight after the minimum possible number of phases.
Help Vova to make up a strategy! You may assume that Vova never runs out of healing potions, and that he can always win.
Input
The first line contains three integers h1, a1, c1 (1 ≤ h1, a1 ≤ 100, 2 ≤ c1 ≤ 100) — Vova's health, Vova's attack power and the healing power of a potion.
The second line contains two integers h2, a2 (1 ≤ h2 ≤ 100, 1 ≤ a2 < c1) — the Modcrab's health and his attack power.
Output
In the first line print one integer n denoting the minimum number of phases required to win the battle.
Then print n lines. i-th line must be equal to HEAL if Vova drinks a potion in i-th phase, or STRIKE if he attacks the Modcrab.
The strategy must be valid: Vova's character must not be defeated before slaying the Modcrab, and the monster's health must be 0 or lower after Vova's last action.
If there are multiple optimal solutions, print any of them.
Examples
Input
10 6 100
17 5
Output
4
STRIKE
HEAL
STRIKE
STRIKE
Input
11 6 100
12 5
Output
2
STRIKE
STRIKE
Note
In the first example Vova's character must heal before or after his first attack. Otherwise his health will drop to zero in 2 phases while he needs 3 strikes to win.
In the second example no healing needed, two strikes are enough to get monster to zero health and win with 6 health left.
Submitted Solution:
```
import math
h1, a1, c1 = map(int,input().split(' '))
h2, a2 = map(int,input().split(' '))
x=math.ceil(h2/a1)
z=x*a2
y=max(0,math.ceil((z-h1)/c1))
print(x+y)
for i in range(0,y):
print("HEAL")
for i in range(0,x):
print("STRIKE")
```
|
instruction
| 0
| 3,896
| 2
| 7,792
|
No
|
output
| 1
| 3,896
| 2
| 7,793
|
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
Vova is again playing some computer game, now an RPG. In the game Vova's character received a quest: to slay the fearsome monster called Modcrab.
After two hours of playing the game Vova has tracked the monster and analyzed its tactics. The Modcrab has h2 health points and an attack power of a2. Knowing that, Vova has decided to buy a lot of strong healing potions and to prepare for battle.
Vova's character has h1 health points and an attack power of a1. Also he has a large supply of healing potions, each of which increases his current amount of health points by c1 when Vova drinks a potion. All potions are identical to each other. It is guaranteed that c1 > a2.
The battle consists of multiple phases. In the beginning of each phase, Vova can either attack the monster (thus reducing its health by a1) or drink a healing potion (it increases Vova's health by c1; Vova's health can exceed h1). Then, if the battle is not over yet, the Modcrab attacks Vova, reducing his health by a2. The battle ends when Vova's (or Modcrab's) health drops to 0 or lower. It is possible that the battle ends in a middle of a phase after Vova's attack.
Of course, Vova wants to win the fight. But also he wants to do it as fast as possible. So he wants to make up a strategy that will allow him to win the fight after the minimum possible number of phases.
Help Vova to make up a strategy! You may assume that Vova never runs out of healing potions, and that he can always win.
Input
The first line contains three integers h1, a1, c1 (1 ≤ h1, a1 ≤ 100, 2 ≤ c1 ≤ 100) — Vova's health, Vova's attack power and the healing power of a potion.
The second line contains two integers h2, a2 (1 ≤ h2 ≤ 100, 1 ≤ a2 < c1) — the Modcrab's health and his attack power.
Output
In the first line print one integer n denoting the minimum number of phases required to win the battle.
Then print n lines. i-th line must be equal to HEAL if Vova drinks a potion in i-th phase, or STRIKE if he attacks the Modcrab.
The strategy must be valid: Vova's character must not be defeated before slaying the Modcrab, and the monster's health must be 0 or lower after Vova's last action.
If there are multiple optimal solutions, print any of them.
Examples
Input
10 6 100
17 5
Output
4
STRIKE
HEAL
STRIKE
STRIKE
Input
11 6 100
12 5
Output
2
STRIKE
STRIKE
Note
In the first example Vova's character must heal before or after his first attack. Otherwise his health will drop to zero in 2 phases while he needs 3 strikes to win.
In the second example no healing needed, two strikes are enough to get monster to zero health and win with 6 health left.
Submitted Solution:
```
import math
first_line = input().split(' ')
second_line = input().split(' ')
h1 = int(first_line[0])
a1 = int(first_line[1])
c1 = int(first_line[2])
h2 = int(second_line[0])
a2 = int(second_line[1])
strike_num = math.ceil(h2 / a1)
print(strike_num)
heal_num = math.ceil(max(0, ((strike_num - 1) * a2 - h1 + 1)) / (c1 - a2))
print(heal_num)
print(strike_num + heal_num)
print('HEAL\n' * heal_num, end='')
print("STRIKE\n" * strike_num, end='')
```
|
instruction
| 0
| 3,897
| 2
| 7,794
|
No
|
output
| 1
| 3,897
| 2
| 7,795
|
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
Igor K. very much likes a multiplayer role playing game WineAge II. Who knows, perhaps, that might be the reason for his poor performance at the university. As any person who plays the game, he is interested in equipping his hero with as good weapon and outfit as possible.
One day, as he was reading the game's forum yet again, he discovered a very interesting fact. As it turns out, each weapon in the game is characterised with k different numbers: a1, ..., ak. They are called hit indicators and according to the game developers' plan they are pairwise coprime.
The damage that is inflicted during a hit depends not only on the weapon's characteristics, but also on the hero's strength parameter. Thus, if the hero's strength equals n, than the inflicted damage will be calculated as the number of numbers on the segment <image>, that aren't divisible by any hit indicator ai.
Recently, having fulfilled another quest, Igor K. found a new Lostborn sword. He wants to know how much damage he will inflict upon his enemies if he uses it.
Input
The first line contains two integers: n and k (1 ≤ n ≤ 1013, 1 ≤ k ≤ 100). They are the indicator of Igor K's hero's strength and the number of hit indicators.
The next line contains space-separated k integers ai (1 ≤ ai ≤ 1000). They are Lostborn sword's hit indicators. The given k numbers are pairwise coprime.
Output
Print the single number — the damage that will be inflicted by Igor K.'s hero when he uses his new weapon.
Please, do not use the %lld specificator to read or write 64-bit integers in C++. It is preferred to use the cin, cout streams or the %I64d specificator.
Examples
Input
20 3
2 3 5
Output
6
Input
50 2
15 8
Output
41
Submitted Solution:
```
first=input().split()
seconde=input().split()
all=int(first[0])
n=int(first[1])
li=[int(x) for x in seconde]
panding=[False for x in range(all+1)]
for i in li:
n=i
while n<=all:
panding[n]=True
n+=i
print(panding.count(False-1))
```
|
instruction
| 0
| 5,569
| 2
| 11,138
|
No
|
output
| 1
| 5,569
| 2
| 11,139
|
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
Igor K. very much likes a multiplayer role playing game WineAge II. Who knows, perhaps, that might be the reason for his poor performance at the university. As any person who plays the game, he is interested in equipping his hero with as good weapon and outfit as possible.
One day, as he was reading the game's forum yet again, he discovered a very interesting fact. As it turns out, each weapon in the game is characterised with k different numbers: a1, ..., ak. They are called hit indicators and according to the game developers' plan they are pairwise coprime.
The damage that is inflicted during a hit depends not only on the weapon's characteristics, but also on the hero's strength parameter. Thus, if the hero's strength equals n, than the inflicted damage will be calculated as the number of numbers on the segment <image>, that aren't divisible by any hit indicator ai.
Recently, having fulfilled another quest, Igor K. found a new Lostborn sword. He wants to know how much damage he will inflict upon his enemies if he uses it.
Input
The first line contains two integers: n and k (1 ≤ n ≤ 1013, 1 ≤ k ≤ 100). They are the indicator of Igor K's hero's strength and the number of hit indicators.
The next line contains space-separated k integers ai (1 ≤ ai ≤ 1000). They are Lostborn sword's hit indicators. The given k numbers are pairwise coprime.
Output
Print the single number — the damage that will be inflicted by Igor K.'s hero when he uses his new weapon.
Please, do not use the %lld specificator to read or write 64-bit integers in C++. It is preferred to use the cin, cout streams or the %I64d specificator.
Examples
Input
20 3
2 3 5
Output
6
Input
50 2
15 8
Output
41
Submitted Solution:
```
def dp(idx,n):
if idx==K or n==0: return n
if n<1010 and ~memo[idx][n]: return memo[idx][n]
ans = dp(idx+1,n)-dp(idx+1,n//v[idx])
if n<1010: memo[idx][n] = ans
return ans
memo = [[-1]*1010]*110
N, K = map(int,input().split())
v = sorted(map(int,input().split()),reverse=True)
print(dp(0,N))
```
|
instruction
| 0
| 5,570
| 2
| 11,140
|
No
|
output
| 1
| 5,570
| 2
| 11,141
|
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.