message stringlengths 2 22.7k | message_type stringclasses 2 values | message_id int64 0 1 | conversation_id int64 145 109k | cluster float64 9 9 | __index_level_0__ int64 290 217k |
|---|---|---|---|---|---|
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
How to make a cake you'll never eat.
Ingredients.
* 2 carrots
* 0 calories
* 100 g chocolate spread
* 1 pack of flour
* 1 egg
Method.
1. Put calories into the mixing bowl.
2. Take carrots from refrigerator.
3. Chop carrots.
4. Take chocolate spread from refrigerator.
5. Put chocolate spread into the mixing bowl.
6. Combine pack of flour into the mixing bowl.
7. Fold chocolate spread into the mixing bowl.
8. Add chocolate spread into the mixing bowl.
9. Put pack of flour into the mixing bowl.
10. Add egg into the mixing bowl.
11. Fold pack of flour into the mixing bowl.
12. Chop carrots until choped.
13. Pour contents of the mixing bowl into the baking dish.
Serves 1.
Input
The only line of input contains a sequence of integers a0, a1, ... (1 ≤ a0 ≤ 100, 0 ≤ ai ≤ 1000 for i ≥ 1).
Output
Output a single integer.
Examples
Input
4 1 2 3 4
Output
30
Submitted Solution:
```
num = input().split()
k = 0
num = num[1:]
for i in num:
k += int(i)
print(k*3)
``` | instruction | 0 | 62,562 | 9 | 125,124 |
No | output | 1 | 62,562 | 9 | 125,125 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
Valera had two bags of potatoes, the first of these bags contains x (x ≥ 1) potatoes, and the second — y (y ≥ 1) potatoes. Valera — very scattered boy, so the first bag of potatoes (it contains x potatoes) Valera lost. Valera remembers that the total amount of potatoes (x + y) in the two bags, firstly, was not gerater than n, and, secondly, was divisible by k.
Help Valera to determine how many potatoes could be in the first bag. Print all such possible numbers in ascending order.
Input
The first line of input contains three integers y, k, n (1 ≤ y, k, n ≤ 109; <image> ≤ 105).
Output
Print the list of whitespace-separated integers — all possible values of x in ascending order. You should print each possible value of x exactly once.
If there are no such values of x print a single integer -1.
Examples
Input
10 1 10
Output
-1
Input
10 6 40
Output
2 8 14 20 26
Submitted Solution:
```
y,k,n=map(int,input().split(' '))
r_x = n-y
#print(r_x)
j=(k-(y%k))
#j = (n-(n%k))-y
#print(j)
if j<=r_x and j>=1:
for i in range(j,r_x+1,k):
print(i, end=' ')
else:
print(-1)
``` | instruction | 0 | 62,602 | 9 | 125,204 |
Yes | output | 1 | 62,602 | 9 | 125,205 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
Valera had two bags of potatoes, the first of these bags contains x (x ≥ 1) potatoes, and the second — y (y ≥ 1) potatoes. Valera — very scattered boy, so the first bag of potatoes (it contains x potatoes) Valera lost. Valera remembers that the total amount of potatoes (x + y) in the two bags, firstly, was not gerater than n, and, secondly, was divisible by k.
Help Valera to determine how many potatoes could be in the first bag. Print all such possible numbers in ascending order.
Input
The first line of input contains three integers y, k, n (1 ≤ y, k, n ≤ 109; <image> ≤ 105).
Output
Print the list of whitespace-separated integers — all possible values of x in ascending order. You should print each possible value of x exactly once.
If there are no such values of x print a single integer -1.
Examples
Input
10 1 10
Output
-1
Input
10 6 40
Output
2 8 14 20 26
Submitted Solution:
```
y,k,n=map(int,input().split())
s=''
for i in range(y//k +1, n//k +1):
s+=str(k*i - y)+' '
if(s==''):
print(-1)
else:
print(s)
``` | instruction | 0 | 62,604 | 9 | 125,208 |
Yes | output | 1 | 62,604 | 9 | 125,209 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
Valera had two bags of potatoes, the first of these bags contains x (x ≥ 1) potatoes, and the second — y (y ≥ 1) potatoes. Valera — very scattered boy, so the first bag of potatoes (it contains x potatoes) Valera lost. Valera remembers that the total amount of potatoes (x + y) in the two bags, firstly, was not gerater than n, and, secondly, was divisible by k.
Help Valera to determine how many potatoes could be in the first bag. Print all such possible numbers in ascending order.
Input
The first line of input contains three integers y, k, n (1 ≤ y, k, n ≤ 109; <image> ≤ 105).
Output
Print the list of whitespace-separated integers — all possible values of x in ascending order. You should print each possible value of x exactly once.
If there are no such values of x print a single integer -1.
Examples
Input
10 1 10
Output
-1
Input
10 6 40
Output
2 8 14 20 26
Submitted Solution:
```
y, k, n = list(map(int, input().split()))
mx = n - y + 1
fx = (((y // k) + 1) * k) - y
if fx < mx :
for x in range(fx, mx, k) :
print(x, end = ' ')
print()
else :
print(-1)
``` | instruction | 0 | 62,605 | 9 | 125,210 |
Yes | output | 1 | 62,605 | 9 | 125,211 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
Valera had two bags of potatoes, the first of these bags contains x (x ≥ 1) potatoes, and the second — y (y ≥ 1) potatoes. Valera — very scattered boy, so the first bag of potatoes (it contains x potatoes) Valera lost. Valera remembers that the total amount of potatoes (x + y) in the two bags, firstly, was not gerater than n, and, secondly, was divisible by k.
Help Valera to determine how many potatoes could be in the first bag. Print all such possible numbers in ascending order.
Input
The first line of input contains three integers y, k, n (1 ≤ y, k, n ≤ 109; <image> ≤ 105).
Output
Print the list of whitespace-separated integers — all possible values of x in ascending order. You should print each possible value of x exactly once.
If there are no such values of x print a single integer -1.
Examples
Input
10 1 10
Output
-1
Input
10 6 40
Output
2 8 14 20 26
Submitted Solution:
```
import math
a,b,c=map(int,input().split())
x=a//2
sum=2
l=[]
count=0
s=' '
for i in range(1,x+1,1):
l.append(sum)
sum+=b
for i in range(0,len(l),1):
if(l[i]<c):
count+=1
if(count==x and l):
for i in l:
print(i,end=' ')
print()
else:
print(-1)
``` | instruction | 0 | 62,606 | 9 | 125,212 |
No | output | 1 | 62,606 | 9 | 125,213 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
Valera had two bags of potatoes, the first of these bags contains x (x ≥ 1) potatoes, and the second — y (y ≥ 1) potatoes. Valera — very scattered boy, so the first bag of potatoes (it contains x potatoes) Valera lost. Valera remembers that the total amount of potatoes (x + y) in the two bags, firstly, was not gerater than n, and, secondly, was divisible by k.
Help Valera to determine how many potatoes could be in the first bag. Print all such possible numbers in ascending order.
Input
The first line of input contains three integers y, k, n (1 ≤ y, k, n ≤ 109; <image> ≤ 105).
Output
Print the list of whitespace-separated integers — all possible values of x in ascending order. You should print each possible value of x exactly once.
If there are no such values of x print a single integer -1.
Examples
Input
10 1 10
Output
-1
Input
10 6 40
Output
2 8 14 20 26
Submitted Solution:
```
try:
y,k,n = map(int,input().split())
l = []
if n-y<k:
print(-1)
else:
q = y//k
q = q+1
while k*q <= n:
l.append(k*q - y )
q = q+1
print(l)
except Exception:
pass
``` | instruction | 0 | 62,607 | 9 | 125,214 |
No | output | 1 | 62,607 | 9 | 125,215 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
Valera had two bags of potatoes, the first of these bags contains x (x ≥ 1) potatoes, and the second — y (y ≥ 1) potatoes. Valera — very scattered boy, so the first bag of potatoes (it contains x potatoes) Valera lost. Valera remembers that the total amount of potatoes (x + y) in the two bags, firstly, was not gerater than n, and, secondly, was divisible by k.
Help Valera to determine how many potatoes could be in the first bag. Print all such possible numbers in ascending order.
Input
The first line of input contains three integers y, k, n (1 ≤ y, k, n ≤ 109; <image> ≤ 105).
Output
Print the list of whitespace-separated integers — all possible values of x in ascending order. You should print each possible value of x exactly once.
If there are no such values of x print a single integer -1.
Examples
Input
10 1 10
Output
-1
Input
10 6 40
Output
2 8 14 20 26
Submitted Solution:
```
y, k, n = map(int, input().split())
x = k
lst = []
while x + y <= n:
if (x + y) % k == 0:
lst.append(x)
x += k
if len(lst) < 1:
print(-1)
lst.sort()
for ans in lst:
print(ans, end=" ")
``` | instruction | 0 | 62,608 | 9 | 125,216 |
No | output | 1 | 62,608 | 9 | 125,217 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
Valera had two bags of potatoes, the first of these bags contains x (x ≥ 1) potatoes, and the second — y (y ≥ 1) potatoes. Valera — very scattered boy, so the first bag of potatoes (it contains x potatoes) Valera lost. Valera remembers that the total amount of potatoes (x + y) in the two bags, firstly, was not gerater than n, and, secondly, was divisible by k.
Help Valera to determine how many potatoes could be in the first bag. Print all such possible numbers in ascending order.
Input
The first line of input contains three integers y, k, n (1 ≤ y, k, n ≤ 109; <image> ≤ 105).
Output
Print the list of whitespace-separated integers — all possible values of x in ascending order. You should print each possible value of x exactly once.
If there are no such values of x print a single integer -1.
Examples
Input
10 1 10
Output
-1
Input
10 6 40
Output
2 8 14 20 26
Submitted Solution:
```
w=list(map(int,input().split()))
x=w[0]
divide=w[1]
divide1=w[1]
sum=w[2]
y=1
i=0
ans=[]
if x==sum:
ans+= [-1]
while x+y<=sum:
if divide-x>0:
ans+=[divide-x]
divide+=divide1
y=divide-x
else:
divide=divide*2
if len(ans)==0:
ans+=[-1]
i=0
while (i < len(ans)):
print(ans[i],end=" ")
i+=1
``` | instruction | 0 | 62,609 | 9 | 125,218 |
No | output | 1 | 62,609 | 9 | 125,219 |
Provide tags and a correct Python 3 solution for this coding contest problem.
It's a very unfortunate day for Volodya today. He got bad mark in algebra and was therefore forced to do some work in the kitchen, namely to cook borscht (traditional Russian soup). This should also improve his algebra skills.
According to the borscht recipe it consists of n ingredients that have to be mixed in proportion <image> litres (thus, there should be a1 ·x, ..., an ·x litres of corresponding ingredients mixed for some non-negative x). In the kitchen Volodya found out that he has b1, ..., bn litres of these ingredients at his disposal correspondingly. In order to correct his algebra mistakes he ought to cook as much soup as possible in a V litres volume pan (which means the amount of soup cooked can be between 0 and V litres). What is the volume of borscht Volodya will cook ultimately?
Input
The first line of the input contains two space-separated integers n and V (1 ≤ n ≤ 20, 1 ≤ V ≤ 10000). The next line contains n space-separated integers ai (1 ≤ ai ≤ 100). Finally, the last line contains n space-separated integers bi (0 ≤ bi ≤ 100).
Output
Your program should output just one real number — the volume of soup that Volodya will cook. Your answer must have a relative or absolute error less than 10 - 4.
Examples
Input
1 100
1
40
Output
40.0
Input
2 100
1 1
25 30
Output
50.0
Input
2 100
1 1
60 60
Output
100.0 | instruction | 0 | 62,671 | 9 | 125,342 |
Tags: greedy, implementation
Correct Solution:
```
n, vol = map(int, input().split())
ratio = list(map(int, input().split()))
ing = list(map(int, input().split()))
ks = [ing[i]/ratio[i] for i in range(n)]
k = min(ks)
print(min(k * sum(ratio), vol))
``` | output | 1 | 62,671 | 9 | 125,343 |
Provide tags and a correct Python 3 solution for this coding contest problem.
It's a very unfortunate day for Volodya today. He got bad mark in algebra and was therefore forced to do some work in the kitchen, namely to cook borscht (traditional Russian soup). This should also improve his algebra skills.
According to the borscht recipe it consists of n ingredients that have to be mixed in proportion <image> litres (thus, there should be a1 ·x, ..., an ·x litres of corresponding ingredients mixed for some non-negative x). In the kitchen Volodya found out that he has b1, ..., bn litres of these ingredients at his disposal correspondingly. In order to correct his algebra mistakes he ought to cook as much soup as possible in a V litres volume pan (which means the amount of soup cooked can be between 0 and V litres). What is the volume of borscht Volodya will cook ultimately?
Input
The first line of the input contains two space-separated integers n and V (1 ≤ n ≤ 20, 1 ≤ V ≤ 10000). The next line contains n space-separated integers ai (1 ≤ ai ≤ 100). Finally, the last line contains n space-separated integers bi (0 ≤ bi ≤ 100).
Output
Your program should output just one real number — the volume of soup that Volodya will cook. Your answer must have a relative or absolute error less than 10 - 4.
Examples
Input
1 100
1
40
Output
40.0
Input
2 100
1 1
25 30
Output
50.0
Input
2 100
1 1
60 60
Output
100.0 | instruction | 0 | 62,672 | 9 | 125,344 |
Tags: greedy, implementation
Correct Solution:
```
n,v=map(int,input().split())
a=list(map(int,input().split()))
b=list(map(int,input().split()))
w=[int(x) for x in range(n)]
for i in range(n):
w[i]=float(b[i]/a[i])
w.sort()
print(min(w[0]*sum(a),v))
``` | output | 1 | 62,672 | 9 | 125,345 |
Provide tags and a correct Python 3 solution for this coding contest problem.
It's a very unfortunate day for Volodya today. He got bad mark in algebra and was therefore forced to do some work in the kitchen, namely to cook borscht (traditional Russian soup). This should also improve his algebra skills.
According to the borscht recipe it consists of n ingredients that have to be mixed in proportion <image> litres (thus, there should be a1 ·x, ..., an ·x litres of corresponding ingredients mixed for some non-negative x). In the kitchen Volodya found out that he has b1, ..., bn litres of these ingredients at his disposal correspondingly. In order to correct his algebra mistakes he ought to cook as much soup as possible in a V litres volume pan (which means the amount of soup cooked can be between 0 and V litres). What is the volume of borscht Volodya will cook ultimately?
Input
The first line of the input contains two space-separated integers n and V (1 ≤ n ≤ 20, 1 ≤ V ≤ 10000). The next line contains n space-separated integers ai (1 ≤ ai ≤ 100). Finally, the last line contains n space-separated integers bi (0 ≤ bi ≤ 100).
Output
Your program should output just one real number — the volume of soup that Volodya will cook. Your answer must have a relative or absolute error less than 10 - 4.
Examples
Input
1 100
1
40
Output
40.0
Input
2 100
1 1
25 30
Output
50.0
Input
2 100
1 1
60 60
Output
100.0 | instruction | 0 | 62,673 | 9 | 125,346 |
Tags: greedy, implementation
Correct Solution:
```
I=lambda:map(int,input().split())
n,v=map(int,input().split())
a,b,q=[*I()],[*I()],0
import math
for i in a:q=math.gcd(q,i)
for i in range(n):a[i]//=q;b[i]=b[i]/a[i]
print(min(min(b)*sum(a),v))
``` | output | 1 | 62,673 | 9 | 125,347 |
Provide tags and a correct Python 3 solution for this coding contest problem.
It's a very unfortunate day for Volodya today. He got bad mark in algebra and was therefore forced to do some work in the kitchen, namely to cook borscht (traditional Russian soup). This should also improve his algebra skills.
According to the borscht recipe it consists of n ingredients that have to be mixed in proportion <image> litres (thus, there should be a1 ·x, ..., an ·x litres of corresponding ingredients mixed for some non-negative x). In the kitchen Volodya found out that he has b1, ..., bn litres of these ingredients at his disposal correspondingly. In order to correct his algebra mistakes he ought to cook as much soup as possible in a V litres volume pan (which means the amount of soup cooked can be between 0 and V litres). What is the volume of borscht Volodya will cook ultimately?
Input
The first line of the input contains two space-separated integers n and V (1 ≤ n ≤ 20, 1 ≤ V ≤ 10000). The next line contains n space-separated integers ai (1 ≤ ai ≤ 100). Finally, the last line contains n space-separated integers bi (0 ≤ bi ≤ 100).
Output
Your program should output just one real number — the volume of soup that Volodya will cook. Your answer must have a relative or absolute error less than 10 - 4.
Examples
Input
1 100
1
40
Output
40.0
Input
2 100
1 1
25 30
Output
50.0
Input
2 100
1 1
60 60
Output
100.0 | instruction | 0 | 62,674 | 9 | 125,348 |
Tags: greedy, implementation
Correct Solution:
```
'''
15.07.2021
CF 041 A
'''
s = (input ()).split ()
n = int (s [0])
v = int (s [1])
s = (input ()).split ()
a = [0]*n
sa = 0
for i in range (n) :
a [i] = int (s [i])
sa += a [i]
s = (input ()).split ()
b = [0]*n
ok = 1
for i in range (n) :
b [i] = int (s [i])
if b [i] == 0 :
ok = 0
#print (a)
#print (b)
x = [0]*n
if ok == 0 :
print (0)
else :
for i in range (n) :
x [i] = a [i] * v / sa
kmin = b [0] / x [0]
for i in range (1, n) :
if x [i] > b [i] :
if b [i] / x [i] < kmin :
kmin = b [i] / x [i]
sum = 0
for i in range (n) :
x [i] *= kmin
sum += x [i]
if sum > v :
sum = v
print (sum)
# print (' '.join (str (s) for s in x))
# print (x)
``` | output | 1 | 62,674 | 9 | 125,349 |
Provide tags and a correct Python 3 solution for this coding contest problem.
It's a very unfortunate day for Volodya today. He got bad mark in algebra and was therefore forced to do some work in the kitchen, namely to cook borscht (traditional Russian soup). This should also improve his algebra skills.
According to the borscht recipe it consists of n ingredients that have to be mixed in proportion <image> litres (thus, there should be a1 ·x, ..., an ·x litres of corresponding ingredients mixed for some non-negative x). In the kitchen Volodya found out that he has b1, ..., bn litres of these ingredients at his disposal correspondingly. In order to correct his algebra mistakes he ought to cook as much soup as possible in a V litres volume pan (which means the amount of soup cooked can be between 0 and V litres). What is the volume of borscht Volodya will cook ultimately?
Input
The first line of the input contains two space-separated integers n and V (1 ≤ n ≤ 20, 1 ≤ V ≤ 10000). The next line contains n space-separated integers ai (1 ≤ ai ≤ 100). Finally, the last line contains n space-separated integers bi (0 ≤ bi ≤ 100).
Output
Your program should output just one real number — the volume of soup that Volodya will cook. Your answer must have a relative or absolute error less than 10 - 4.
Examples
Input
1 100
1
40
Output
40.0
Input
2 100
1 1
25 30
Output
50.0
Input
2 100
1 1
60 60
Output
100.0 | instruction | 0 | 62,675 | 9 | 125,350 |
Tags: greedy, implementation
Correct Solution:
```
n, capacity = map(int, input().split())
proportions = list(map(int, input().split()))
ingredients = list(map(int, input().split()))
best_volume = 0
for i, ingredientA in enumerate(ingredients):
proportionA = proportions[i]
volume = 0
feasible = True
#print('ingredientA = %d' % ingredientA)
for j, ingredientB in enumerate(ingredients):
proportionB = proportions[j]
amount = ingredientA / proportionA * proportionB
#print('amount = %f, ingredientB = %d' % (amount, ingredientB))
if amount > ingredientB + 1e-9:
#print('*** delta = %f' % (amount - ingredientB))
feasible = False
break
#print('ingredient %d: %f' % (j, amount))
volume += amount
if not feasible:
#print('not feasible')
continue
volume = min(capacity, volume)
best_volume = max(best_volume, volume)
print(best_volume)
``` | output | 1 | 62,675 | 9 | 125,351 |
Provide tags and a correct Python 3 solution for this coding contest problem.
It's a very unfortunate day for Volodya today. He got bad mark in algebra and was therefore forced to do some work in the kitchen, namely to cook borscht (traditional Russian soup). This should also improve his algebra skills.
According to the borscht recipe it consists of n ingredients that have to be mixed in proportion <image> litres (thus, there should be a1 ·x, ..., an ·x litres of corresponding ingredients mixed for some non-negative x). In the kitchen Volodya found out that he has b1, ..., bn litres of these ingredients at his disposal correspondingly. In order to correct his algebra mistakes he ought to cook as much soup as possible in a V litres volume pan (which means the amount of soup cooked can be between 0 and V litres). What is the volume of borscht Volodya will cook ultimately?
Input
The first line of the input contains two space-separated integers n and V (1 ≤ n ≤ 20, 1 ≤ V ≤ 10000). The next line contains n space-separated integers ai (1 ≤ ai ≤ 100). Finally, the last line contains n space-separated integers bi (0 ≤ bi ≤ 100).
Output
Your program should output just one real number — the volume of soup that Volodya will cook. Your answer must have a relative or absolute error less than 10 - 4.
Examples
Input
1 100
1
40
Output
40.0
Input
2 100
1 1
25 30
Output
50.0
Input
2 100
1 1
60 60
Output
100.0 | instruction | 0 | 62,676 | 9 | 125,352 |
Tags: greedy, implementation
Correct Solution:
```
n, V = map(int, input().split())
a = list(map(int, input().split()))
b = list(map(int, input().split()))
d = min(b[i] / a[i] for i in range(n))
print(min(V, d * sum(a)))
``` | output | 1 | 62,676 | 9 | 125,353 |
Provide tags and a correct Python 3 solution for this coding contest problem.
It's a very unfortunate day for Volodya today. He got bad mark in algebra and was therefore forced to do some work in the kitchen, namely to cook borscht (traditional Russian soup). This should also improve his algebra skills.
According to the borscht recipe it consists of n ingredients that have to be mixed in proportion <image> litres (thus, there should be a1 ·x, ..., an ·x litres of corresponding ingredients mixed for some non-negative x). In the kitchen Volodya found out that he has b1, ..., bn litres of these ingredients at his disposal correspondingly. In order to correct his algebra mistakes he ought to cook as much soup as possible in a V litres volume pan (which means the amount of soup cooked can be between 0 and V litres). What is the volume of borscht Volodya will cook ultimately?
Input
The first line of the input contains two space-separated integers n and V (1 ≤ n ≤ 20, 1 ≤ V ≤ 10000). The next line contains n space-separated integers ai (1 ≤ ai ≤ 100). Finally, the last line contains n space-separated integers bi (0 ≤ bi ≤ 100).
Output
Your program should output just one real number — the volume of soup that Volodya will cook. Your answer must have a relative or absolute error less than 10 - 4.
Examples
Input
1 100
1
40
Output
40.0
Input
2 100
1 1
25 30
Output
50.0
Input
2 100
1 1
60 60
Output
100.0 | instruction | 0 | 62,677 | 9 | 125,354 |
Tags: greedy, implementation
Correct Solution:
```
n, V = input().split()
n, V = int(n), int(V)
a = list(map(int, input().split()))
b = list(map(int, input().split()))
ratio = 100000
for i in range(n):
ratio = min(ratio, b[i]/a[i])
suma = 0
for i in range(n):
suma += ratio * a[i]
print(min(V, suma))
``` | output | 1 | 62,677 | 9 | 125,355 |
Provide tags and a correct Python 3 solution for this coding contest problem.
It's a very unfortunate day for Volodya today. He got bad mark in algebra and was therefore forced to do some work in the kitchen, namely to cook borscht (traditional Russian soup). This should also improve his algebra skills.
According to the borscht recipe it consists of n ingredients that have to be mixed in proportion <image> litres (thus, there should be a1 ·x, ..., an ·x litres of corresponding ingredients mixed for some non-negative x). In the kitchen Volodya found out that he has b1, ..., bn litres of these ingredients at his disposal correspondingly. In order to correct his algebra mistakes he ought to cook as much soup as possible in a V litres volume pan (which means the amount of soup cooked can be between 0 and V litres). What is the volume of borscht Volodya will cook ultimately?
Input
The first line of the input contains two space-separated integers n and V (1 ≤ n ≤ 20, 1 ≤ V ≤ 10000). The next line contains n space-separated integers ai (1 ≤ ai ≤ 100). Finally, the last line contains n space-separated integers bi (0 ≤ bi ≤ 100).
Output
Your program should output just one real number — the volume of soup that Volodya will cook. Your answer must have a relative or absolute error less than 10 - 4.
Examples
Input
1 100
1
40
Output
40.0
Input
2 100
1 1
25 30
Output
50.0
Input
2 100
1 1
60 60
Output
100.0 | instruction | 0 | 62,678 | 9 | 125,356 |
Tags: greedy, implementation
Correct Solution:
```
n, V = map(int, input().split())
a = list(map(int, input().split()))
b = list(map(int, input().split()))
Sa=sum(a)
m = min(b)
res = 0
for i in range(n):
cur_r = 0
for j in range(n):
if(b[j]>=a[j]*b[i]/a[i]):
cur_r += a[j]*b[i]/a[i]
else:
break
else:
res = max(cur_r, res)
print(min(res, float(V)))
``` | output | 1 | 62,678 | 9 | 125,357 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
It's a very unfortunate day for Volodya today. He got bad mark in algebra and was therefore forced to do some work in the kitchen, namely to cook borscht (traditional Russian soup). This should also improve his algebra skills.
According to the borscht recipe it consists of n ingredients that have to be mixed in proportion <image> litres (thus, there should be a1 ·x, ..., an ·x litres of corresponding ingredients mixed for some non-negative x). In the kitchen Volodya found out that he has b1, ..., bn litres of these ingredients at his disposal correspondingly. In order to correct his algebra mistakes he ought to cook as much soup as possible in a V litres volume pan (which means the amount of soup cooked can be between 0 and V litres). What is the volume of borscht Volodya will cook ultimately?
Input
The first line of the input contains two space-separated integers n and V (1 ≤ n ≤ 20, 1 ≤ V ≤ 10000). The next line contains n space-separated integers ai (1 ≤ ai ≤ 100). Finally, the last line contains n space-separated integers bi (0 ≤ bi ≤ 100).
Output
Your program should output just one real number — the volume of soup that Volodya will cook. Your answer must have a relative or absolute error less than 10 - 4.
Examples
Input
1 100
1
40
Output
40.0
Input
2 100
1 1
25 30
Output
50.0
Input
2 100
1 1
60 60
Output
100.0
Submitted Solution:
```
n , v = map(int,input().split())
ratio = list(map(int,input().split()))
lis = list(map(int,input().split()))
ans=[]
for i in range(n):
a = lis[i]/ratio[i]
ans.append(a)
x = min(ans)
ss=0
#print(ans)
for i in ratio:
ss+=(i*x)
print(min(v,ss))
``` | instruction | 0 | 62,679 | 9 | 125,358 |
Yes | output | 1 | 62,679 | 9 | 125,359 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
It's a very unfortunate day for Volodya today. He got bad mark in algebra and was therefore forced to do some work in the kitchen, namely to cook borscht (traditional Russian soup). This should also improve his algebra skills.
According to the borscht recipe it consists of n ingredients that have to be mixed in proportion <image> litres (thus, there should be a1 ·x, ..., an ·x litres of corresponding ingredients mixed for some non-negative x). In the kitchen Volodya found out that he has b1, ..., bn litres of these ingredients at his disposal correspondingly. In order to correct his algebra mistakes he ought to cook as much soup as possible in a V litres volume pan (which means the amount of soup cooked can be between 0 and V litres). What is the volume of borscht Volodya will cook ultimately?
Input
The first line of the input contains two space-separated integers n and V (1 ≤ n ≤ 20, 1 ≤ V ≤ 10000). The next line contains n space-separated integers ai (1 ≤ ai ≤ 100). Finally, the last line contains n space-separated integers bi (0 ≤ bi ≤ 100).
Output
Your program should output just one real number — the volume of soup that Volodya will cook. Your answer must have a relative or absolute error less than 10 - 4.
Examples
Input
1 100
1
40
Output
40.0
Input
2 100
1 1
25 30
Output
50.0
Input
2 100
1 1
60 60
Output
100.0
Submitted Solution:
```
n,V = list(map(int, input().split(" ")))
ratios = list(map(int, input().split(" ")))
available = list(map(int, input().split(" ")))
resulting = min([available[i]/ratios[i] for i in range(n)])
volume = sum([resulting*ratio for ratio in ratios])
print(min(volume, V))
``` | instruction | 0 | 62,680 | 9 | 125,360 |
Yes | output | 1 | 62,680 | 9 | 125,361 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
It's a very unfortunate day for Volodya today. He got bad mark in algebra and was therefore forced to do some work in the kitchen, namely to cook borscht (traditional Russian soup). This should also improve his algebra skills.
According to the borscht recipe it consists of n ingredients that have to be mixed in proportion <image> litres (thus, there should be a1 ·x, ..., an ·x litres of corresponding ingredients mixed for some non-negative x). In the kitchen Volodya found out that he has b1, ..., bn litres of these ingredients at his disposal correspondingly. In order to correct his algebra mistakes he ought to cook as much soup as possible in a V litres volume pan (which means the amount of soup cooked can be between 0 and V litres). What is the volume of borscht Volodya will cook ultimately?
Input
The first line of the input contains two space-separated integers n and V (1 ≤ n ≤ 20, 1 ≤ V ≤ 10000). The next line contains n space-separated integers ai (1 ≤ ai ≤ 100). Finally, the last line contains n space-separated integers bi (0 ≤ bi ≤ 100).
Output
Your program should output just one real number — the volume of soup that Volodya will cook. Your answer must have a relative or absolute error less than 10 - 4.
Examples
Input
1 100
1
40
Output
40.0
Input
2 100
1 1
25 30
Output
50.0
Input
2 100
1 1
60 60
Output
100.0
Submitted Solution:
```
n,V=map(int, input().strip().split(' '))
a=list(map(int, input().strip().split(' ')))
b=list(map(int, input().strip().split(' ')))
l=[]
for i in range(n):
l.append(b[i]/a[i])
m=min(l)
s=sum(a)
print(min((m*s),V))
``` | instruction | 0 | 62,681 | 9 | 125,362 |
Yes | output | 1 | 62,681 | 9 | 125,363 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
It's a very unfortunate day for Volodya today. He got bad mark in algebra and was therefore forced to do some work in the kitchen, namely to cook borscht (traditional Russian soup). This should also improve his algebra skills.
According to the borscht recipe it consists of n ingredients that have to be mixed in proportion <image> litres (thus, there should be a1 ·x, ..., an ·x litres of corresponding ingredients mixed for some non-negative x). In the kitchen Volodya found out that he has b1, ..., bn litres of these ingredients at his disposal correspondingly. In order to correct his algebra mistakes he ought to cook as much soup as possible in a V litres volume pan (which means the amount of soup cooked can be between 0 and V litres). What is the volume of borscht Volodya will cook ultimately?
Input
The first line of the input contains two space-separated integers n and V (1 ≤ n ≤ 20, 1 ≤ V ≤ 10000). The next line contains n space-separated integers ai (1 ≤ ai ≤ 100). Finally, the last line contains n space-separated integers bi (0 ≤ bi ≤ 100).
Output
Your program should output just one real number — the volume of soup that Volodya will cook. Your answer must have a relative or absolute error less than 10 - 4.
Examples
Input
1 100
1
40
Output
40.0
Input
2 100
1 1
25 30
Output
50.0
Input
2 100
1 1
60 60
Output
100.0
Submitted Solution:
```
n,v=map(int,input().split())
a=[int(i) for i in input().split()]
b=[int(i) for i in input().split()]
mini=10**9
for i in range(n):
mini=min(mini,b[i]/a[i])
sm=0
for i in range(n):
sm=sm+mini*a[i]
print(min(sm,v))
``` | instruction | 0 | 62,682 | 9 | 125,364 |
Yes | output | 1 | 62,682 | 9 | 125,365 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
It's a very unfortunate day for Volodya today. He got bad mark in algebra and was therefore forced to do some work in the kitchen, namely to cook borscht (traditional Russian soup). This should also improve his algebra skills.
According to the borscht recipe it consists of n ingredients that have to be mixed in proportion <image> litres (thus, there should be a1 ·x, ..., an ·x litres of corresponding ingredients mixed for some non-negative x). In the kitchen Volodya found out that he has b1, ..., bn litres of these ingredients at his disposal correspondingly. In order to correct his algebra mistakes he ought to cook as much soup as possible in a V litres volume pan (which means the amount of soup cooked can be between 0 and V litres). What is the volume of borscht Volodya will cook ultimately?
Input
The first line of the input contains two space-separated integers n and V (1 ≤ n ≤ 20, 1 ≤ V ≤ 10000). The next line contains n space-separated integers ai (1 ≤ ai ≤ 100). Finally, the last line contains n space-separated integers bi (0 ≤ bi ≤ 100).
Output
Your program should output just one real number — the volume of soup that Volodya will cook. Your answer must have a relative or absolute error less than 10 - 4.
Examples
Input
1 100
1
40
Output
40.0
Input
2 100
1 1
25 30
Output
50.0
Input
2 100
1 1
60 60
Output
100.0
Submitted Solution:
```
n,v=map(int,input().split())
a=[int(i) for i in input().split()]
b=[int(i) for i in input().split()]
maxa=0
for i in range(n):
if a[i]>maxa:
maxa=a[i]
maxb=b[i]
elif a[i]==maxa:
maxb=min(maxb,b[i])
r=maxb/maxa
sm=0
for i in range(n):
sm=sm+r*a[i]
print(min(sm,v))
``` | instruction | 0 | 62,683 | 9 | 125,366 |
No | output | 1 | 62,683 | 9 | 125,367 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
It's a very unfortunate day for Volodya today. He got bad mark in algebra and was therefore forced to do some work in the kitchen, namely to cook borscht (traditional Russian soup). This should also improve his algebra skills.
According to the borscht recipe it consists of n ingredients that have to be mixed in proportion <image> litres (thus, there should be a1 ·x, ..., an ·x litres of corresponding ingredients mixed for some non-negative x). In the kitchen Volodya found out that he has b1, ..., bn litres of these ingredients at his disposal correspondingly. In order to correct his algebra mistakes he ought to cook as much soup as possible in a V litres volume pan (which means the amount of soup cooked can be between 0 and V litres). What is the volume of borscht Volodya will cook ultimately?
Input
The first line of the input contains two space-separated integers n and V (1 ≤ n ≤ 20, 1 ≤ V ≤ 10000). The next line contains n space-separated integers ai (1 ≤ ai ≤ 100). Finally, the last line contains n space-separated integers bi (0 ≤ bi ≤ 100).
Output
Your program should output just one real number — the volume of soup that Volodya will cook. Your answer must have a relative or absolute error less than 10 - 4.
Examples
Input
1 100
1
40
Output
40.0
Input
2 100
1 1
25 30
Output
50.0
Input
2 100
1 1
60 60
Output
100.0
Submitted Solution:
```
I=lambda:map(int,input().split())
n,v=map(int,input().split())
a,b,q=[*I()],[*I()],0
import math
for i in a:q=math.gcd(q,i)
for i in range(n):a[i]=b[i]/(a[i]//q)
print(min(min(a)*n,v))
``` | instruction | 0 | 62,684 | 9 | 125,368 |
No | output | 1 | 62,684 | 9 | 125,369 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
It's a very unfortunate day for Volodya today. He got bad mark in algebra and was therefore forced to do some work in the kitchen, namely to cook borscht (traditional Russian soup). This should also improve his algebra skills.
According to the borscht recipe it consists of n ingredients that have to be mixed in proportion <image> litres (thus, there should be a1 ·x, ..., an ·x litres of corresponding ingredients mixed for some non-negative x). In the kitchen Volodya found out that he has b1, ..., bn litres of these ingredients at his disposal correspondingly. In order to correct his algebra mistakes he ought to cook as much soup as possible in a V litres volume pan (which means the amount of soup cooked can be between 0 and V litres). What is the volume of borscht Volodya will cook ultimately?
Input
The first line of the input contains two space-separated integers n and V (1 ≤ n ≤ 20, 1 ≤ V ≤ 10000). The next line contains n space-separated integers ai (1 ≤ ai ≤ 100). Finally, the last line contains n space-separated integers bi (0 ≤ bi ≤ 100).
Output
Your program should output just one real number — the volume of soup that Volodya will cook. Your answer must have a relative or absolute error less than 10 - 4.
Examples
Input
1 100
1
40
Output
40.0
Input
2 100
1 1
25 30
Output
50.0
Input
2 100
1 1
60 60
Output
100.0
Submitted Solution:
```
import math
n, V = map(int, input().split())
a = list(map(int, input().split()))
b = list(map(int, input().split()))
nb_soup = min([math.floor(b[i]/a[i]) for i in range(n)])
print(min(nb_soup*sum(a), V))
``` | instruction | 0 | 62,685 | 9 | 125,370 |
No | output | 1 | 62,685 | 9 | 125,371 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
It's a very unfortunate day for Volodya today. He got bad mark in algebra and was therefore forced to do some work in the kitchen, namely to cook borscht (traditional Russian soup). This should also improve his algebra skills.
According to the borscht recipe it consists of n ingredients that have to be mixed in proportion <image> litres (thus, there should be a1 ·x, ..., an ·x litres of corresponding ingredients mixed for some non-negative x). In the kitchen Volodya found out that he has b1, ..., bn litres of these ingredients at his disposal correspondingly. In order to correct his algebra mistakes he ought to cook as much soup as possible in a V litres volume pan (which means the amount of soup cooked can be between 0 and V litres). What is the volume of borscht Volodya will cook ultimately?
Input
The first line of the input contains two space-separated integers n and V (1 ≤ n ≤ 20, 1 ≤ V ≤ 10000). The next line contains n space-separated integers ai (1 ≤ ai ≤ 100). Finally, the last line contains n space-separated integers bi (0 ≤ bi ≤ 100).
Output
Your program should output just one real number — the volume of soup that Volodya will cook. Your answer must have a relative or absolute error less than 10 - 4.
Examples
Input
1 100
1
40
Output
40.0
Input
2 100
1 1
25 30
Output
50.0
Input
2 100
1 1
60 60
Output
100.0
Submitted Solution:
```
import math
n, V = map(int, input().split())
a = list(map(int, input().split()))
b = list(map(int, input().split()))
nb_soup = min([math.floor(b[i]/a[i]) for i in range(n)])
sa = sum(a)
V=math.floor(V/sa)*sa
print(min(nb_soup*sa, V))
``` | instruction | 0 | 62,686 | 9 | 125,372 |
No | output | 1 | 62,686 | 9 | 125,373 |
Provide tags and a correct Python 3 solution for this coding contest problem.
There was an epidemic in Monstropolis and all monsters became sick. To recover, all monsters lined up in queue for an appointment to the only doctor in the city.
Soon, monsters became hungry and began to eat each other.
One monster can eat other monster if its weight is strictly greater than the weight of the monster being eaten, and they stand in the queue next to each other. Monsters eat each other instantly. There are no monsters which are being eaten at the same moment. After the monster A eats the monster B, the weight of the monster A increases by the weight of the eaten monster B. In result of such eating the length of the queue decreases by one, all monsters after the eaten one step forward so that there is no empty places in the queue again. A monster can eat several monsters one after another. Initially there were n monsters in the queue, the i-th of which had weight ai.
For example, if weights are [1, 2, 2, 2, 1, 2] (in order of queue, monsters are numbered from 1 to 6 from left to right) then some of the options are:
1. the first monster can't eat the second monster because a1 = 1 is not greater than a2 = 2;
2. the second monster can't eat the third monster because a2 = 2 is not greater than a3 = 2;
3. the second monster can't eat the fifth monster because they are not neighbors;
4. the second monster can eat the first monster, the queue will be transformed to [3, 2, 2, 1, 2].
After some time, someone said a good joke and all monsters recovered. At that moment there were k (k ≤ n) monsters in the queue, the j-th of which had weight bj. Both sequences (a and b) contain the weights of the monsters in the order from the first to the last.
You are required to provide one of the possible orders of eating monsters which led to the current queue, or to determine that this could not happen. Assume that the doctor didn't make any appointments while monsters were eating each other.
Input
The first line contains single integer n (1 ≤ n ≤ 500) — the number of monsters in the initial queue.
The second line contains n integers a1, a2, ..., an (1 ≤ ai ≤ 106) — the initial weights of the monsters.
The third line contains single integer k (1 ≤ k ≤ n) — the number of monsters in the queue after the joke.
The fourth line contains k integers b1, b2, ..., bk (1 ≤ bj ≤ 5·108) — the weights of the monsters after the joke.
Monsters are listed in the order from the beginning of the queue to the end.
Output
In case if no actions could lead to the final queue, print "NO" (without quotes) in the only line.
Otherwise print "YES" (without quotes) in the first line. In the next n - k lines print actions in the chronological order. In each line print x — the index number of the monster in the current queue which eats and, separated by space, the symbol 'L' if the monster which stays the x-th in the queue eats the monster in front of him, or 'R' if the monster which stays the x-th in the queue eats the monster behind him. After each eating the queue is enumerated again.
When one monster eats another the queue decreases. If there are several answers, print any of them.
Examples
Input
6
1 2 2 2 1 2
2
5 5
Output
YES
2 L
1 R
4 L
3 L
Input
5
1 2 3 4 5
1
15
Output
YES
5 L
4 L
3 L
2 L
Input
5
1 1 1 3 3
3
2 1 6
Output
NO
Note
In the first example, initially there were n = 6 monsters, their weights are [1, 2, 2, 2, 1, 2] (in order of queue from the first monster to the last monster). The final queue should be [5, 5]. The following sequence of eatings leads to the final queue:
* the second monster eats the monster to the left (i.e. the first monster), queue becomes [3, 2, 2, 1, 2];
* the first monster (note, it was the second on the previous step) eats the monster to the right (i.e. the second monster), queue becomes [5, 2, 1, 2];
* the fourth monster eats the mosnter to the left (i.e. the third monster), queue becomes [5, 2, 3];
* the finally, the third monster eats the monster to the left (i.e. the second monster), queue becomes [5, 5].
Note that for each step the output contains numbers of the monsters in their current order in the queue. | instruction | 0 | 62,781 | 9 | 125,562 |
Tags: constructive algorithms, dp, greedy, two pointers
Correct Solution:
```
head = 0
result = ""
def maxIndexes(list):
result = []
max = -1
for x in list:
if x > max:
max = x
for i in range(len(list)):
if (list[i] == max):
result.append(i + 1)
return result
def neighborsMax(a):
indexes = maxIndexes(a)
if (len(a) == 1):
return True
for j in indexes:
i = j - 1
if (i == 0):
if (a[0] != a[1]):
return True
elif (i == len(a) - 1):
if (a[-1] != a[-2]):
return True
else:
# print(a, i, indexes)
if (a[i - 1] != a[i] or a[i + 1] != a[i]):
return True
return False
def possible(a, b):
# print(a, b)
if (len(a) < len(b)):
return False
if (len(a) == 1):
return a == b
if(len(b) == 1):
return neighborsMax(a) and sum(a) == b[0]
for i in range(len(a)):
if sum(a[:i]) == b[0]:
# print(i, "****")
return neighborsMax(a[:i]) and possible(a[i:], b[1:])
def startIndex(list):
indexes = maxIndexes(list)
for index in indexes:
if index == 1 and list[1] != list[0]:
return 1
elif (index == len(list) and list[-1] != list[-2]) and (index != 1):
return index
elif ((index - 1) not in indexes or (index + 1) not in indexes) and (index != 1) and (index != len(list)):
return index
def startDirection(list, index):
if index == 1:
return 1
if index == len(list):
return -1
if list[index] != list[index - 1]:
return 1
return -1
def printTimes(start, direction, times):
# print(times, "*****")
if (direction == 1):
for i in range(times):
print(start, "R")
else:
for i in range(times):
print(start - i, "L")
def output(list, head):
index = startIndex(list)
direction = startDirection(list, index)
# print(list, head, index, direction)
if direction == 1:
printTimes(index + head, 1, len(list) - index)
printTimes(index + head, -1, index - 1)
else:
printTimes(index + head, -1, index - 1)
printTimes(index + head - index + 1, 1, len(list) - index)
def eat(a, b, head):
if(len(a) == 1):
return
if (len(b) == 1):
output(a, head)
return
for k in range(len(a)):
if(sum(a[:k]) == b[0]):
eat(a[:k], [b[0]], head)
eat(a[k:], b[1:], head + 1)
n = int(input())
a = str(input()).split()
a = [int(x) for x in a]
k = int(input())
b = str(input()).split()
b = [int(x) for x in b]
isPossible = possible(a, b)
if (isPossible):
print("YES")
eat(a, b, 0)
else:
print("NO")
``` | output | 1 | 62,781 | 9 | 125,563 |
Provide tags and a correct Python 3 solution for this coding contest problem.
There was an epidemic in Monstropolis and all monsters became sick. To recover, all monsters lined up in queue for an appointment to the only doctor in the city.
Soon, monsters became hungry and began to eat each other.
One monster can eat other monster if its weight is strictly greater than the weight of the monster being eaten, and they stand in the queue next to each other. Monsters eat each other instantly. There are no monsters which are being eaten at the same moment. After the monster A eats the monster B, the weight of the monster A increases by the weight of the eaten monster B. In result of such eating the length of the queue decreases by one, all monsters after the eaten one step forward so that there is no empty places in the queue again. A monster can eat several monsters one after another. Initially there were n monsters in the queue, the i-th of which had weight ai.
For example, if weights are [1, 2, 2, 2, 1, 2] (in order of queue, monsters are numbered from 1 to 6 from left to right) then some of the options are:
1. the first monster can't eat the second monster because a1 = 1 is not greater than a2 = 2;
2. the second monster can't eat the third monster because a2 = 2 is not greater than a3 = 2;
3. the second monster can't eat the fifth monster because they are not neighbors;
4. the second monster can eat the first monster, the queue will be transformed to [3, 2, 2, 1, 2].
After some time, someone said a good joke and all monsters recovered. At that moment there were k (k ≤ n) monsters in the queue, the j-th of which had weight bj. Both sequences (a and b) contain the weights of the monsters in the order from the first to the last.
You are required to provide one of the possible orders of eating monsters which led to the current queue, or to determine that this could not happen. Assume that the doctor didn't make any appointments while monsters were eating each other.
Input
The first line contains single integer n (1 ≤ n ≤ 500) — the number of monsters in the initial queue.
The second line contains n integers a1, a2, ..., an (1 ≤ ai ≤ 106) — the initial weights of the monsters.
The third line contains single integer k (1 ≤ k ≤ n) — the number of monsters in the queue after the joke.
The fourth line contains k integers b1, b2, ..., bk (1 ≤ bj ≤ 5·108) — the weights of the monsters after the joke.
Monsters are listed in the order from the beginning of the queue to the end.
Output
In case if no actions could lead to the final queue, print "NO" (without quotes) in the only line.
Otherwise print "YES" (without quotes) in the first line. In the next n - k lines print actions in the chronological order. In each line print x — the index number of the monster in the current queue which eats and, separated by space, the symbol 'L' if the monster which stays the x-th in the queue eats the monster in front of him, or 'R' if the monster which stays the x-th in the queue eats the monster behind him. After each eating the queue is enumerated again.
When one monster eats another the queue decreases. If there are several answers, print any of them.
Examples
Input
6
1 2 2 2 1 2
2
5 5
Output
YES
2 L
1 R
4 L
3 L
Input
5
1 2 3 4 5
1
15
Output
YES
5 L
4 L
3 L
2 L
Input
5
1 1 1 3 3
3
2 1 6
Output
NO
Note
In the first example, initially there were n = 6 monsters, their weights are [1, 2, 2, 2, 1, 2] (in order of queue from the first monster to the last monster). The final queue should be [5, 5]. The following sequence of eatings leads to the final queue:
* the second monster eats the monster to the left (i.e. the first monster), queue becomes [3, 2, 2, 1, 2];
* the first monster (note, it was the second on the previous step) eats the monster to the right (i.e. the second monster), queue becomes [5, 2, 1, 2];
* the fourth monster eats the mosnter to the left (i.e. the third monster), queue becomes [5, 2, 3];
* the finally, the third monster eats the monster to the left (i.e. the second monster), queue becomes [5, 5].
Note that for each step the output contains numbers of the monsters in their current order in the queue. | instruction | 0 | 62,782 | 9 | 125,564 |
Tags: constructive algorithms, dp, greedy, two pointers
Correct Solution:
```
def update(target,threshold):
global track
check = [0]*len(a)
s = 0
for i in range(len(a)):
s+=a[i]
if s == target:
break
if s!=target:
return False
if a[i]==target:
a.pop(0)
return True
max = 0
itrack = 0
for j in range(i+1):
if (j == 0 and a[j]>a[j+1]) or (j==i and a[j]>a[j-1]) or ((0<j<i) and (a[j]>a[j-1] or a[j]>a[j+1])):
if a[j]>max:
max = a[j]
itrack = j
#print(itrack)
iupper = i
ii = itrack
while (1):
if ii>0:
if a[ii]>a[ii-1]:
track.append((threshold+ii+1,'L'))
a[ii]+=a[ii-1]
a.pop(ii-1)
ii-=1
iupper -= 1
elif ii < iupper:
if a[ii]>a[ii+1]:
track.append((threshold+ii+1,'R'))
a[ii]+=a[ii+1]
a.pop(ii+1)
iupper-=1
else:
break
else:
if ii==iupper:
break
if a[ii]>a[ii+1]:
track.append((threshold+ii+1,'R'))
a[ii]+=a[ii+1]
a.pop(ii+1)
iupper-=1
else:
break
if a[0]!=target:
return False
else:
a.pop(0)
return True
n = int(input())
a = [int(i) for i in input().split()]
k = int(input())
b = [int(i) for i in input().split()]
i = 0
j = 0
track = []
check = True
while j<k:
u = update(b[j],j)
if u == False:
check = False
break
j+=1
if len(a)>0 or j<k:
check=False
if not check:
print('NO')
else:
print('YES')
for i in track:
print(i[0],i[1])
``` | output | 1 | 62,782 | 9 | 125,565 |
Provide tags and a correct Python 3 solution for this coding contest problem.
There was an epidemic in Monstropolis and all monsters became sick. To recover, all monsters lined up in queue for an appointment to the only doctor in the city.
Soon, monsters became hungry and began to eat each other.
One monster can eat other monster if its weight is strictly greater than the weight of the monster being eaten, and they stand in the queue next to each other. Monsters eat each other instantly. There are no monsters which are being eaten at the same moment. After the monster A eats the monster B, the weight of the monster A increases by the weight of the eaten monster B. In result of such eating the length of the queue decreases by one, all monsters after the eaten one step forward so that there is no empty places in the queue again. A monster can eat several monsters one after another. Initially there were n monsters in the queue, the i-th of which had weight ai.
For example, if weights are [1, 2, 2, 2, 1, 2] (in order of queue, monsters are numbered from 1 to 6 from left to right) then some of the options are:
1. the first monster can't eat the second monster because a1 = 1 is not greater than a2 = 2;
2. the second monster can't eat the third monster because a2 = 2 is not greater than a3 = 2;
3. the second monster can't eat the fifth monster because they are not neighbors;
4. the second monster can eat the first monster, the queue will be transformed to [3, 2, 2, 1, 2].
After some time, someone said a good joke and all monsters recovered. At that moment there were k (k ≤ n) monsters in the queue, the j-th of which had weight bj. Both sequences (a and b) contain the weights of the monsters in the order from the first to the last.
You are required to provide one of the possible orders of eating monsters which led to the current queue, or to determine that this could not happen. Assume that the doctor didn't make any appointments while monsters were eating each other.
Input
The first line contains single integer n (1 ≤ n ≤ 500) — the number of monsters in the initial queue.
The second line contains n integers a1, a2, ..., an (1 ≤ ai ≤ 106) — the initial weights of the monsters.
The third line contains single integer k (1 ≤ k ≤ n) — the number of monsters in the queue after the joke.
The fourth line contains k integers b1, b2, ..., bk (1 ≤ bj ≤ 5·108) — the weights of the monsters after the joke.
Monsters are listed in the order from the beginning of the queue to the end.
Output
In case if no actions could lead to the final queue, print "NO" (without quotes) in the only line.
Otherwise print "YES" (without quotes) in the first line. In the next n - k lines print actions in the chronological order. In each line print x — the index number of the monster in the current queue which eats and, separated by space, the symbol 'L' if the monster which stays the x-th in the queue eats the monster in front of him, or 'R' if the monster which stays the x-th in the queue eats the monster behind him. After each eating the queue is enumerated again.
When one monster eats another the queue decreases. If there are several answers, print any of them.
Examples
Input
6
1 2 2 2 1 2
2
5 5
Output
YES
2 L
1 R
4 L
3 L
Input
5
1 2 3 4 5
1
15
Output
YES
5 L
4 L
3 L
2 L
Input
5
1 1 1 3 3
3
2 1 6
Output
NO
Note
In the first example, initially there were n = 6 monsters, their weights are [1, 2, 2, 2, 1, 2] (in order of queue from the first monster to the last monster). The final queue should be [5, 5]. The following sequence of eatings leads to the final queue:
* the second monster eats the monster to the left (i.e. the first monster), queue becomes [3, 2, 2, 1, 2];
* the first monster (note, it was the second on the previous step) eats the monster to the right (i.e. the second monster), queue becomes [5, 2, 1, 2];
* the fourth monster eats the mosnter to the left (i.e. the third monster), queue becomes [5, 2, 3];
* the finally, the third monster eats the monster to the left (i.e. the second monster), queue becomes [5, 5].
Note that for each step the output contains numbers of the monsters in their current order in the queue. | instruction | 0 | 62,783 | 9 | 125,566 |
Tags: constructive algorithms, dp, greedy, two pointers
Correct Solution:
```
n = int(input())
a = list(map(int, input().split()))
k = int(input())
b = list(map(int, input().split()))
possible = True
i = 0
j = 0
sub_b = b.copy()
start_index_last_prefix = 0
max_on_prefix = a[start_index_last_prefix]
first_max_on_prefix_index = last_max_on_prefix_index = start_index_last_prefix
actual_finding_max = True
result = []
while possible and i < n and j < k:
this = a[i]
if i == start_index_last_prefix:
max_on_prefix = a[start_index_last_prefix]
first_max_on_prefix_index = last_max_on_prefix_index = start_index_last_prefix
actual_finding_max = True
if this > max_on_prefix:
max_on_prefix = this
first_max_on_prefix_index = last_max_on_prefix_index = i
actual_finding_max = True
elif this == max_on_prefix and actual_finding_max:
last_max_on_prefix_index = i
else:
actual_finding_max = False
sub_b[j] -= this
if sub_b[j] == 0:
if first_max_on_prefix_index != start_index_last_prefix:
number_of_left_eat = first_max_on_prefix_index - start_index_last_prefix
for x in range(number_of_left_eat):
pos = number_of_left_eat - x + 1 + j
step = 'L'
act = str(pos) + ' ' + step
result.append(act)
number_of_right_eat = i - first_max_on_prefix_index
for x in range(number_of_right_eat):
pos = 1 + j
step = 'R'
act = str(pos) + ' ' + step
result.append(act)
elif last_max_on_prefix_index != i:
number_of_right_eat = i - last_max_on_prefix_index
for x in range(number_of_right_eat):
pos = last_max_on_prefix_index - start_index_last_prefix + 1 + j
step = 'R'
act = str(pos) + ' ' + step
result.append(act)
number_of_left_eat = last_max_on_prefix_index - start_index_last_prefix
for x in range(number_of_left_eat):
pos = number_of_left_eat - x + 1 + j
step = 'L'
act = str(pos) + ' ' + step
result.append(act)
elif start_index_last_prefix != i:
possible = False
start_index_last_prefix = i + 1
j += 1
elif sub_b[j] < 0:
possible = False
i += 1
if i != n or j != k:
possible = False
if possible:
print('YES')
print('\n'.join(result))
else:
print("NO")
``` | output | 1 | 62,783 | 9 | 125,567 |
Provide tags and a correct Python 3 solution for this coding contest problem.
There was an epidemic in Monstropolis and all monsters became sick. To recover, all monsters lined up in queue for an appointment to the only doctor in the city.
Soon, monsters became hungry and began to eat each other.
One monster can eat other monster if its weight is strictly greater than the weight of the monster being eaten, and they stand in the queue next to each other. Monsters eat each other instantly. There are no monsters which are being eaten at the same moment. After the monster A eats the monster B, the weight of the monster A increases by the weight of the eaten monster B. In result of such eating the length of the queue decreases by one, all monsters after the eaten one step forward so that there is no empty places in the queue again. A monster can eat several monsters one after another. Initially there were n monsters in the queue, the i-th of which had weight ai.
For example, if weights are [1, 2, 2, 2, 1, 2] (in order of queue, monsters are numbered from 1 to 6 from left to right) then some of the options are:
1. the first monster can't eat the second monster because a1 = 1 is not greater than a2 = 2;
2. the second monster can't eat the third monster because a2 = 2 is not greater than a3 = 2;
3. the second monster can't eat the fifth monster because they are not neighbors;
4. the second monster can eat the first monster, the queue will be transformed to [3, 2, 2, 1, 2].
After some time, someone said a good joke and all monsters recovered. At that moment there were k (k ≤ n) monsters in the queue, the j-th of which had weight bj. Both sequences (a and b) contain the weights of the monsters in the order from the first to the last.
You are required to provide one of the possible orders of eating monsters which led to the current queue, or to determine that this could not happen. Assume that the doctor didn't make any appointments while monsters were eating each other.
Input
The first line contains single integer n (1 ≤ n ≤ 500) — the number of monsters in the initial queue.
The second line contains n integers a1, a2, ..., an (1 ≤ ai ≤ 106) — the initial weights of the monsters.
The third line contains single integer k (1 ≤ k ≤ n) — the number of monsters in the queue after the joke.
The fourth line contains k integers b1, b2, ..., bk (1 ≤ bj ≤ 5·108) — the weights of the monsters after the joke.
Monsters are listed in the order from the beginning of the queue to the end.
Output
In case if no actions could lead to the final queue, print "NO" (without quotes) in the only line.
Otherwise print "YES" (without quotes) in the first line. In the next n - k lines print actions in the chronological order. In each line print x — the index number of the monster in the current queue which eats and, separated by space, the symbol 'L' if the monster which stays the x-th in the queue eats the monster in front of him, or 'R' if the monster which stays the x-th in the queue eats the monster behind him. After each eating the queue is enumerated again.
When one monster eats another the queue decreases. If there are several answers, print any of them.
Examples
Input
6
1 2 2 2 1 2
2
5 5
Output
YES
2 L
1 R
4 L
3 L
Input
5
1 2 3 4 5
1
15
Output
YES
5 L
4 L
3 L
2 L
Input
5
1 1 1 3 3
3
2 1 6
Output
NO
Note
In the first example, initially there were n = 6 monsters, their weights are [1, 2, 2, 2, 1, 2] (in order of queue from the first monster to the last monster). The final queue should be [5, 5]. The following sequence of eatings leads to the final queue:
* the second monster eats the monster to the left (i.e. the first monster), queue becomes [3, 2, 2, 1, 2];
* the first monster (note, it was the second on the previous step) eats the monster to the right (i.e. the second monster), queue becomes [5, 2, 1, 2];
* the fourth monster eats the mosnter to the left (i.e. the third monster), queue becomes [5, 2, 3];
* the finally, the third monster eats the monster to the left (i.e. the second monster), queue becomes [5, 5].
Note that for each step the output contains numbers of the monsters in their current order in the queue. | instruction | 0 | 62,784 | 9 | 125,568 |
Tags: constructive algorithms, dp, greedy, two pointers
Correct Solution:
```
import sys
input = sys.stdin.readline
n = int(input())
a = [int(i) for i in input().split()]
m = int(input())
b = [int(i) for i in input().split()]
j = n-1
ans = []
for k in range(m-1, -1, -1):
sm = 0
i = j
while i >= 0:
sm += a[i]
if sm == b[k]:
if i == j:
pass
else:
mx = max(a[i:j+1])
ii = -1
for x in range(i, j+1):
if a[x] == mx and (x-1 >= i and a[x-1] < a[x] or x+1 <= j and a[x] > a[x+1]):
ii = x
if ii == -1:
print('NO')
exit()
L, R = ii - i, j - ii
if ii-1 >= i and a[ii-1] < a[ii]:
for _ in range(L):
ans.append((ii+1, 'L'))
ii -= 1
for _ in range(R):
ans.append((ii+1, 'R'))
else:
for _ in range(R):
ans.append((ii+1, 'R'))
for _ in range(L):
ans.append((ii+1, 'L'))
ii -= 1
j = i - 1
b[k] = 0
break
elif sm > b[k]:
print('NO')
exit()
i -= 1
if j >= 0 or max(b) > 0:
print('NO')
else:
print('YES')
for tu in ans:
print(*tu)
``` | output | 1 | 62,784 | 9 | 125,569 |
Provide tags and a correct Python 3 solution for this coding contest problem.
There was an epidemic in Monstropolis and all monsters became sick. To recover, all monsters lined up in queue for an appointment to the only doctor in the city.
Soon, monsters became hungry and began to eat each other.
One monster can eat other monster if its weight is strictly greater than the weight of the monster being eaten, and they stand in the queue next to each other. Monsters eat each other instantly. There are no monsters which are being eaten at the same moment. After the monster A eats the monster B, the weight of the monster A increases by the weight of the eaten monster B. In result of such eating the length of the queue decreases by one, all monsters after the eaten one step forward so that there is no empty places in the queue again. A monster can eat several monsters one after another. Initially there were n monsters in the queue, the i-th of which had weight ai.
For example, if weights are [1, 2, 2, 2, 1, 2] (in order of queue, monsters are numbered from 1 to 6 from left to right) then some of the options are:
1. the first monster can't eat the second monster because a1 = 1 is not greater than a2 = 2;
2. the second monster can't eat the third monster because a2 = 2 is not greater than a3 = 2;
3. the second monster can't eat the fifth monster because they are not neighbors;
4. the second monster can eat the first monster, the queue will be transformed to [3, 2, 2, 1, 2].
After some time, someone said a good joke and all monsters recovered. At that moment there were k (k ≤ n) monsters in the queue, the j-th of which had weight bj. Both sequences (a and b) contain the weights of the monsters in the order from the first to the last.
You are required to provide one of the possible orders of eating monsters which led to the current queue, or to determine that this could not happen. Assume that the doctor didn't make any appointments while monsters were eating each other.
Input
The first line contains single integer n (1 ≤ n ≤ 500) — the number of monsters in the initial queue.
The second line contains n integers a1, a2, ..., an (1 ≤ ai ≤ 106) — the initial weights of the monsters.
The third line contains single integer k (1 ≤ k ≤ n) — the number of monsters in the queue after the joke.
The fourth line contains k integers b1, b2, ..., bk (1 ≤ bj ≤ 5·108) — the weights of the monsters after the joke.
Monsters are listed in the order from the beginning of the queue to the end.
Output
In case if no actions could lead to the final queue, print "NO" (without quotes) in the only line.
Otherwise print "YES" (without quotes) in the first line. In the next n - k lines print actions in the chronological order. In each line print x — the index number of the monster in the current queue which eats and, separated by space, the symbol 'L' if the monster which stays the x-th in the queue eats the monster in front of him, or 'R' if the monster which stays the x-th in the queue eats the monster behind him. After each eating the queue is enumerated again.
When one monster eats another the queue decreases. If there are several answers, print any of them.
Examples
Input
6
1 2 2 2 1 2
2
5 5
Output
YES
2 L
1 R
4 L
3 L
Input
5
1 2 3 4 5
1
15
Output
YES
5 L
4 L
3 L
2 L
Input
5
1 1 1 3 3
3
2 1 6
Output
NO
Note
In the first example, initially there were n = 6 monsters, their weights are [1, 2, 2, 2, 1, 2] (in order of queue from the first monster to the last monster). The final queue should be [5, 5]. The following sequence of eatings leads to the final queue:
* the second monster eats the monster to the left (i.e. the first monster), queue becomes [3, 2, 2, 1, 2];
* the first monster (note, it was the second on the previous step) eats the monster to the right (i.e. the second monster), queue becomes [5, 2, 1, 2];
* the fourth monster eats the mosnter to the left (i.e. the third monster), queue becomes [5, 2, 3];
* the finally, the third monster eats the monster to the left (i.e. the second monster), queue becomes [5, 5].
Note that for each step the output contains numbers of the monsters in their current order in the queue. | instruction | 0 | 62,785 | 9 | 125,570 |
Tags: constructive algorithms, dp, greedy, two pointers
Correct Solution:
```
def main():
def helper(i):
if l[i] > l[i - 1]:
res.append("%d L" % (i + j))
i -= 1
elif l[i] > l[i + 1]:
res.append("%d R" % (i + j))
else:
return
l[i] += l.pop(i + 1)
helper(i)
inf, res, _ = 1 << 30, ["YES"], input()
aa, _ = [*map(int, input().split()), inf], input()
lo = hi = 0
for j, b in enumerate(map(int, input().split()), 1):
while b > 0:
b -= aa[hi]
hi += 1
if b:
break
l, lo = aa[lo:hi], hi
m = max(l)
l.append(inf)
for i, a in enumerate(l):
if a == m:
helper(i)
if len(l) > 2:
b = 1
break
print("NO" if b or aa[hi] < inf else '\n'.join(res))
if __name__ == '__main__':
main()
``` | output | 1 | 62,785 | 9 | 125,571 |
Provide tags and a correct Python 3 solution for this coding contest problem.
There was an epidemic in Monstropolis and all monsters became sick. To recover, all monsters lined up in queue for an appointment to the only doctor in the city.
Soon, monsters became hungry and began to eat each other.
One monster can eat other monster if its weight is strictly greater than the weight of the monster being eaten, and they stand in the queue next to each other. Monsters eat each other instantly. There are no monsters which are being eaten at the same moment. After the monster A eats the monster B, the weight of the monster A increases by the weight of the eaten monster B. In result of such eating the length of the queue decreases by one, all monsters after the eaten one step forward so that there is no empty places in the queue again. A monster can eat several monsters one after another. Initially there were n monsters in the queue, the i-th of which had weight ai.
For example, if weights are [1, 2, 2, 2, 1, 2] (in order of queue, monsters are numbered from 1 to 6 from left to right) then some of the options are:
1. the first monster can't eat the second monster because a1 = 1 is not greater than a2 = 2;
2. the second monster can't eat the third monster because a2 = 2 is not greater than a3 = 2;
3. the second monster can't eat the fifth monster because they are not neighbors;
4. the second monster can eat the first monster, the queue will be transformed to [3, 2, 2, 1, 2].
After some time, someone said a good joke and all monsters recovered. At that moment there were k (k ≤ n) monsters in the queue, the j-th of which had weight bj. Both sequences (a and b) contain the weights of the monsters in the order from the first to the last.
You are required to provide one of the possible orders of eating monsters which led to the current queue, or to determine that this could not happen. Assume that the doctor didn't make any appointments while monsters were eating each other.
Input
The first line contains single integer n (1 ≤ n ≤ 500) — the number of monsters in the initial queue.
The second line contains n integers a1, a2, ..., an (1 ≤ ai ≤ 106) — the initial weights of the monsters.
The third line contains single integer k (1 ≤ k ≤ n) — the number of monsters in the queue after the joke.
The fourth line contains k integers b1, b2, ..., bk (1 ≤ bj ≤ 5·108) — the weights of the monsters after the joke.
Monsters are listed in the order from the beginning of the queue to the end.
Output
In case if no actions could lead to the final queue, print "NO" (without quotes) in the only line.
Otherwise print "YES" (without quotes) in the first line. In the next n - k lines print actions in the chronological order. In each line print x — the index number of the monster in the current queue which eats and, separated by space, the symbol 'L' if the monster which stays the x-th in the queue eats the monster in front of him, or 'R' if the monster which stays the x-th in the queue eats the monster behind him. After each eating the queue is enumerated again.
When one monster eats another the queue decreases. If there are several answers, print any of them.
Examples
Input
6
1 2 2 2 1 2
2
5 5
Output
YES
2 L
1 R
4 L
3 L
Input
5
1 2 3 4 5
1
15
Output
YES
5 L
4 L
3 L
2 L
Input
5
1 1 1 3 3
3
2 1 6
Output
NO
Note
In the first example, initially there were n = 6 monsters, their weights are [1, 2, 2, 2, 1, 2] (in order of queue from the first monster to the last monster). The final queue should be [5, 5]. The following sequence of eatings leads to the final queue:
* the second monster eats the monster to the left (i.e. the first monster), queue becomes [3, 2, 2, 1, 2];
* the first monster (note, it was the second on the previous step) eats the monster to the right (i.e. the second monster), queue becomes [5, 2, 1, 2];
* the fourth monster eats the mosnter to the left (i.e. the third monster), queue becomes [5, 2, 3];
* the finally, the third monster eats the monster to the left (i.e. the second monster), queue becomes [5, 5].
Note that for each step the output contains numbers of the monsters in their current order in the queue. | instruction | 0 | 62,786 | 9 | 125,572 |
Tags: constructive algorithms, dp, greedy, two pointers
Correct Solution:
```
n = int(input())
init = list(map(int, input().split()))
k = int(input())
after = list(map(int, input().split()))
prev, cur, t = -1, 0, 0
ans = []
if sum(init) != sum(after):
print("NO")
exit()
for i in range(n):
t += init[i]
if t == after[cur] and cur < k:
cur += 1
t = 0
ans.append((prev + 1, i))
prev = i
if cur != k:
print("NO")
else:
res = []
for i in range(len(ans)):
s, f = ans[i][0], ans[i][1]
if s == f: continue
mx = max(init[s:f+1])
j = -1
l = True
for ii in range(s, f + 1):
if init[ii] == mx:
if ii - 1 >= s and init[ii] > init[ii - 1]:
j = ii
l = True
break
if ii + 1 <= f and init[ii] > init[ii + 1]:
j = ii
l = False
break
if j == -1:
print("NO")
exit()
if l:
for ij in reversed(range(2, j - s + 2)):
res.append((i + ij, 'L'))
for _ in range(f - j):
res.append((i + 1, 'R'))
else:
for _ in range(f - j):
res.append((i + j - s + 1, 'R'))
for ij in reversed(range(2, j - s + 2)):
res.append((i + ij, 'L'))
print("YES")
for _ in range(len(res)):
print(*res[_])
``` | output | 1 | 62,786 | 9 | 125,573 |
Provide tags and a correct Python 3 solution for this coding contest problem.
There was an epidemic in Monstropolis and all monsters became sick. To recover, all monsters lined up in queue for an appointment to the only doctor in the city.
Soon, monsters became hungry and began to eat each other.
One monster can eat other monster if its weight is strictly greater than the weight of the monster being eaten, and they stand in the queue next to each other. Monsters eat each other instantly. There are no monsters which are being eaten at the same moment. After the monster A eats the monster B, the weight of the monster A increases by the weight of the eaten monster B. In result of such eating the length of the queue decreases by one, all monsters after the eaten one step forward so that there is no empty places in the queue again. A monster can eat several monsters one after another. Initially there were n monsters in the queue, the i-th of which had weight ai.
For example, if weights are [1, 2, 2, 2, 1, 2] (in order of queue, monsters are numbered from 1 to 6 from left to right) then some of the options are:
1. the first monster can't eat the second monster because a1 = 1 is not greater than a2 = 2;
2. the second monster can't eat the third monster because a2 = 2 is not greater than a3 = 2;
3. the second monster can't eat the fifth monster because they are not neighbors;
4. the second monster can eat the first monster, the queue will be transformed to [3, 2, 2, 1, 2].
After some time, someone said a good joke and all monsters recovered. At that moment there were k (k ≤ n) monsters in the queue, the j-th of which had weight bj. Both sequences (a and b) contain the weights of the monsters in the order from the first to the last.
You are required to provide one of the possible orders of eating monsters which led to the current queue, or to determine that this could not happen. Assume that the doctor didn't make any appointments while monsters were eating each other.
Input
The first line contains single integer n (1 ≤ n ≤ 500) — the number of monsters in the initial queue.
The second line contains n integers a1, a2, ..., an (1 ≤ ai ≤ 106) — the initial weights of the monsters.
The third line contains single integer k (1 ≤ k ≤ n) — the number of monsters in the queue after the joke.
The fourth line contains k integers b1, b2, ..., bk (1 ≤ bj ≤ 5·108) — the weights of the monsters after the joke.
Monsters are listed in the order from the beginning of the queue to the end.
Output
In case if no actions could lead to the final queue, print "NO" (without quotes) in the only line.
Otherwise print "YES" (without quotes) in the first line. In the next n - k lines print actions in the chronological order. In each line print x — the index number of the monster in the current queue which eats and, separated by space, the symbol 'L' if the monster which stays the x-th in the queue eats the monster in front of him, or 'R' if the monster which stays the x-th in the queue eats the monster behind him. After each eating the queue is enumerated again.
When one monster eats another the queue decreases. If there are several answers, print any of them.
Examples
Input
6
1 2 2 2 1 2
2
5 5
Output
YES
2 L
1 R
4 L
3 L
Input
5
1 2 3 4 5
1
15
Output
YES
5 L
4 L
3 L
2 L
Input
5
1 1 1 3 3
3
2 1 6
Output
NO
Note
In the first example, initially there were n = 6 monsters, their weights are [1, 2, 2, 2, 1, 2] (in order of queue from the first monster to the last monster). The final queue should be [5, 5]. The following sequence of eatings leads to the final queue:
* the second monster eats the monster to the left (i.e. the first monster), queue becomes [3, 2, 2, 1, 2];
* the first monster (note, it was the second on the previous step) eats the monster to the right (i.e. the second monster), queue becomes [5, 2, 1, 2];
* the fourth monster eats the mosnter to the left (i.e. the third monster), queue becomes [5, 2, 3];
* the finally, the third monster eats the monster to the left (i.e. the second monster), queue becomes [5, 5].
Note that for each step the output contains numbers of the monsters in their current order in the queue. | instruction | 0 | 62,787 | 9 | 125,574 |
Tags: constructive algorithms, dp, greedy, two pointers
Correct Solution:
```
#!/usr/bin/env python3
import sys
class Node(object):
def __init__(self, v, n, p, idx):
self.next = n
self.prev = p
self.value = v
self.idx = idx
def remove_next(self):
if self.next == None:
return
if self.next.next == None:
self.next = None
return
self.next = self.next.next
self.next.prev = self
def remove_prev(self):
if self.prev == None:
return
if self.prev.prev == None:
self.prev = None
return
self.prev = self.prev.prev
self.prev.next = self
n = input('')
weights = list(map(int, input('').split(' ')))
k = input('')
weights_after = list(map(int, input('').split(' ')))
groups = []
start = 0
for v in weights_after:
# Consume values from n until the sum is v
total = 0
group = []
for i in range(start, len(weights)):
total += weights[i]
group.append(weights[i])
if total > v:
# It is impossible
print('NO')
sys.exit(0)
elif total == v:
start = i + 1
break
if len(group) == 0 or (len(set(group)) == 1 and group[0] != v):
# It is impossible
print('NO')
sys.exit(0)
groups.append(group)
if start != len(weights):
print('NO')
sys.exit(0)
print('YES')
# For each of the groups, try and collapse them
start = 0
for g in groups:
if len(g) == 1:
# don't have to do anything
start += 1
continue
biggest_value = g[max(range(len(g)), key=g.__getitem__)]
biggest_item = []
n = Node(g[0], None, None, 0)
if g[0] == biggest_value:
biggest_item.append(n)
for i in range(1, len(g)):
n.next = Node(g[i], None, n, i)
n = n.next
if g[i] == biggest_value:
biggest_item.append(n)
starting = None
for n in biggest_item:
if n.prev is not None and n.prev.value < n.value:
starting = n
break
if n.next is not None and n.next.value < n.value:
starting = n
break
while True:
if starting.next is not None and starting.next.value < starting.value:
print(start + starting.idx + 1, 'R')
starting.value += starting.next.value
starting.remove_next()
continue
if starting.prev is not None and starting.prev.value < starting.value:
print(start + starting.idx + 1, 'L')
starting.idx -= 1
starting.value += starting.prev.value
starting.remove_prev()
continue
break
start += 1
``` | output | 1 | 62,787 | 9 | 125,575 |
Provide tags and a correct Python 3 solution for this coding contest problem.
There was an epidemic in Monstropolis and all monsters became sick. To recover, all monsters lined up in queue for an appointment to the only doctor in the city.
Soon, monsters became hungry and began to eat each other.
One monster can eat other monster if its weight is strictly greater than the weight of the monster being eaten, and they stand in the queue next to each other. Monsters eat each other instantly. There are no monsters which are being eaten at the same moment. After the monster A eats the monster B, the weight of the monster A increases by the weight of the eaten monster B. In result of such eating the length of the queue decreases by one, all monsters after the eaten one step forward so that there is no empty places in the queue again. A monster can eat several monsters one after another. Initially there were n monsters in the queue, the i-th of which had weight ai.
For example, if weights are [1, 2, 2, 2, 1, 2] (in order of queue, monsters are numbered from 1 to 6 from left to right) then some of the options are:
1. the first monster can't eat the second monster because a1 = 1 is not greater than a2 = 2;
2. the second monster can't eat the third monster because a2 = 2 is not greater than a3 = 2;
3. the second monster can't eat the fifth monster because they are not neighbors;
4. the second monster can eat the first monster, the queue will be transformed to [3, 2, 2, 1, 2].
After some time, someone said a good joke and all monsters recovered. At that moment there were k (k ≤ n) monsters in the queue, the j-th of which had weight bj. Both sequences (a and b) contain the weights of the monsters in the order from the first to the last.
You are required to provide one of the possible orders of eating monsters which led to the current queue, or to determine that this could not happen. Assume that the doctor didn't make any appointments while monsters were eating each other.
Input
The first line contains single integer n (1 ≤ n ≤ 500) — the number of monsters in the initial queue.
The second line contains n integers a1, a2, ..., an (1 ≤ ai ≤ 106) — the initial weights of the monsters.
The third line contains single integer k (1 ≤ k ≤ n) — the number of monsters in the queue after the joke.
The fourth line contains k integers b1, b2, ..., bk (1 ≤ bj ≤ 5·108) — the weights of the monsters after the joke.
Monsters are listed in the order from the beginning of the queue to the end.
Output
In case if no actions could lead to the final queue, print "NO" (without quotes) in the only line.
Otherwise print "YES" (without quotes) in the first line. In the next n - k lines print actions in the chronological order. In each line print x — the index number of the monster in the current queue which eats and, separated by space, the symbol 'L' if the monster which stays the x-th in the queue eats the monster in front of him, or 'R' if the monster which stays the x-th in the queue eats the monster behind him. After each eating the queue is enumerated again.
When one monster eats another the queue decreases. If there are several answers, print any of them.
Examples
Input
6
1 2 2 2 1 2
2
5 5
Output
YES
2 L
1 R
4 L
3 L
Input
5
1 2 3 4 5
1
15
Output
YES
5 L
4 L
3 L
2 L
Input
5
1 1 1 3 3
3
2 1 6
Output
NO
Note
In the first example, initially there were n = 6 monsters, their weights are [1, 2, 2, 2, 1, 2] (in order of queue from the first monster to the last monster). The final queue should be [5, 5]. The following sequence of eatings leads to the final queue:
* the second monster eats the monster to the left (i.e. the first monster), queue becomes [3, 2, 2, 1, 2];
* the first monster (note, it was the second on the previous step) eats the monster to the right (i.e. the second monster), queue becomes [5, 2, 1, 2];
* the fourth monster eats the mosnter to the left (i.e. the third monster), queue becomes [5, 2, 3];
* the finally, the third monster eats the monster to the left (i.e. the second monster), queue becomes [5, 5].
Note that for each step the output contains numbers of the monsters in their current order in the queue. | instruction | 0 | 62,788 | 9 | 125,576 |
Tags: constructive algorithms, dp, greedy, two pointers
Correct Solution:
```
import timeit
def inp():
return list(map(int, input().split()))
def a():
return timeit.default_timer()
def main():
n = int(input())
A = inp()
m = int(input())
B = inp()
D=0
F=[]
j=0
k=0
for i in range(n):
if k>m-1:
return [-1]
D+=A[i]
if D == B[k]:
C = A[j:i+1]
D=0
j=i+1
k+=1
if len(C)==1:
continue
while len(C) != 1:
x=a()
E=list(C)
t=E.index(max(E))
while not((t<len(E)-1 and C[t]>C[t+1])or(t>0 and C[t]>C[t-1])):
E[t]=0
t=E.index(max(E))
if max(E)==0:
return [-1]
E=list(C)
if t<len(E)-1:
if C[t] > C[t+1]:
C[t:t+2]=[C[t]+C[t+1]]
F.append(str(t+k)+" R")
continue
if t>0:
if C[t] > C[t-1]:
C[t-1:t+1] = [C[t]+C[t-1]]
F.append(str(t+k)+" L")
continue
elif D > B[k]:
return [-1]
if k!=m:
return[-1]
else:
return F
temp = main()
if temp == [-1]:
print("NO")
else:
print("YES")
for i in temp:
print(i)
``` | output | 1 | 62,788 | 9 | 125,577 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
There was an epidemic in Monstropolis and all monsters became sick. To recover, all monsters lined up in queue for an appointment to the only doctor in the city.
Soon, monsters became hungry and began to eat each other.
One monster can eat other monster if its weight is strictly greater than the weight of the monster being eaten, and they stand in the queue next to each other. Monsters eat each other instantly. There are no monsters which are being eaten at the same moment. After the monster A eats the monster B, the weight of the monster A increases by the weight of the eaten monster B. In result of such eating the length of the queue decreases by one, all monsters after the eaten one step forward so that there is no empty places in the queue again. A monster can eat several monsters one after another. Initially there were n monsters in the queue, the i-th of which had weight ai.
For example, if weights are [1, 2, 2, 2, 1, 2] (in order of queue, monsters are numbered from 1 to 6 from left to right) then some of the options are:
1. the first monster can't eat the second monster because a1 = 1 is not greater than a2 = 2;
2. the second monster can't eat the third monster because a2 = 2 is not greater than a3 = 2;
3. the second monster can't eat the fifth monster because they are not neighbors;
4. the second monster can eat the first monster, the queue will be transformed to [3, 2, 2, 1, 2].
After some time, someone said a good joke and all monsters recovered. At that moment there were k (k ≤ n) monsters in the queue, the j-th of which had weight bj. Both sequences (a and b) contain the weights of the monsters in the order from the first to the last.
You are required to provide one of the possible orders of eating monsters which led to the current queue, or to determine that this could not happen. Assume that the doctor didn't make any appointments while monsters were eating each other.
Input
The first line contains single integer n (1 ≤ n ≤ 500) — the number of monsters in the initial queue.
The second line contains n integers a1, a2, ..., an (1 ≤ ai ≤ 106) — the initial weights of the monsters.
The third line contains single integer k (1 ≤ k ≤ n) — the number of monsters in the queue after the joke.
The fourth line contains k integers b1, b2, ..., bk (1 ≤ bj ≤ 5·108) — the weights of the monsters after the joke.
Monsters are listed in the order from the beginning of the queue to the end.
Output
In case if no actions could lead to the final queue, print "NO" (without quotes) in the only line.
Otherwise print "YES" (without quotes) in the first line. In the next n - k lines print actions in the chronological order. In each line print x — the index number of the monster in the current queue which eats and, separated by space, the symbol 'L' if the monster which stays the x-th in the queue eats the monster in front of him, or 'R' if the monster which stays the x-th in the queue eats the monster behind him. After each eating the queue is enumerated again.
When one monster eats another the queue decreases. If there are several answers, print any of them.
Examples
Input
6
1 2 2 2 1 2
2
5 5
Output
YES
2 L
1 R
4 L
3 L
Input
5
1 2 3 4 5
1
15
Output
YES
5 L
4 L
3 L
2 L
Input
5
1 1 1 3 3
3
2 1 6
Output
NO
Note
In the first example, initially there were n = 6 monsters, their weights are [1, 2, 2, 2, 1, 2] (in order of queue from the first monster to the last monster). The final queue should be [5, 5]. The following sequence of eatings leads to the final queue:
* the second monster eats the monster to the left (i.e. the first monster), queue becomes [3, 2, 2, 1, 2];
* the first monster (note, it was the second on the previous step) eats the monster to the right (i.e. the second monster), queue becomes [5, 2, 1, 2];
* the fourth monster eats the mosnter to the left (i.e. the third monster), queue becomes [5, 2, 3];
* the finally, the third monster eats the monster to the left (i.e. the second monster), queue becomes [5, 5].
Note that for each step the output contains numbers of the monsters in their current order in the queue.
Submitted Solution:
```
ans = []
def search(j1, j):
m = max(a[j1: j])
if a[j1] == m and a[j1] > a[j1 + 1]:
return j1
if a[j - 1] == m and a[j - 1] > a[j - 2]:
return j - 1
for i in range(j1 + 1, j - 1):
if a[i] == m and (a[i] > a[i - 1] or a[i] > a[i + 1]):
return i
def merge(j1, j):
c = search(j1, j)
if j1 < c < j - 1:
if a[c] > a[c + 1]:
for i in range(c, j - 1):
ans.append([c - d + 1, 'R'])
for i in range(c - j1):
ans.append([c - i - d + 1, 'L'])
else:
for i in range(c - j1):
ans.append([c - i - d + 1, 'L'])
for i in range(c, j - 1):
ans.append([j1 - d + 1, 'R'])
elif c == j1:
for i in range(j1, j - 1):
ans.append([c - d + 1, 'R'])
else:
for i in range(j - 1 - j1):
ans.append([j - 1 - i - d + 1, 'L'])
n = int(input())
a = list(map(int, input().split()))
k = int(input())
b = list(map(int, input().split()))
can = 'YES'
j = 0
d = 0
for i in range(k):
j1 = j
r = True
s = 0
while j < n and s < b[i]:
if j > j1 and a[j] != a[j - 1]:
r = False
s += a[j]
j += 1
if (r and j - j1 > 1) or (s != b[i]) or (i < k - 1 and j == n) :
can = 'NO'
break
if j - j1 > 1:
merge(j1, j)
d += j - j1 - 1
if j < n:
can = 'NO'
print(can)
if can == 'YES':
for i in range(len(ans)):
print(ans[i][0], ans[i][1])
``` | instruction | 0 | 62,789 | 9 | 125,578 |
Yes | output | 1 | 62,789 | 9 | 125,579 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
There was an epidemic in Monstropolis and all monsters became sick. To recover, all monsters lined up in queue for an appointment to the only doctor in the city.
Soon, monsters became hungry and began to eat each other.
One monster can eat other monster if its weight is strictly greater than the weight of the monster being eaten, and they stand in the queue next to each other. Monsters eat each other instantly. There are no monsters which are being eaten at the same moment. After the monster A eats the monster B, the weight of the monster A increases by the weight of the eaten monster B. In result of such eating the length of the queue decreases by one, all monsters after the eaten one step forward so that there is no empty places in the queue again. A monster can eat several monsters one after another. Initially there were n monsters in the queue, the i-th of which had weight ai.
For example, if weights are [1, 2, 2, 2, 1, 2] (in order of queue, monsters are numbered from 1 to 6 from left to right) then some of the options are:
1. the first monster can't eat the second monster because a1 = 1 is not greater than a2 = 2;
2. the second monster can't eat the third monster because a2 = 2 is not greater than a3 = 2;
3. the second monster can't eat the fifth monster because they are not neighbors;
4. the second monster can eat the first monster, the queue will be transformed to [3, 2, 2, 1, 2].
After some time, someone said a good joke and all monsters recovered. At that moment there were k (k ≤ n) monsters in the queue, the j-th of which had weight bj. Both sequences (a and b) contain the weights of the monsters in the order from the first to the last.
You are required to provide one of the possible orders of eating monsters which led to the current queue, or to determine that this could not happen. Assume that the doctor didn't make any appointments while monsters were eating each other.
Input
The first line contains single integer n (1 ≤ n ≤ 500) — the number of monsters in the initial queue.
The second line contains n integers a1, a2, ..., an (1 ≤ ai ≤ 106) — the initial weights of the monsters.
The third line contains single integer k (1 ≤ k ≤ n) — the number of monsters in the queue after the joke.
The fourth line contains k integers b1, b2, ..., bk (1 ≤ bj ≤ 5·108) — the weights of the monsters after the joke.
Monsters are listed in the order from the beginning of the queue to the end.
Output
In case if no actions could lead to the final queue, print "NO" (without quotes) in the only line.
Otherwise print "YES" (without quotes) in the first line. In the next n - k lines print actions in the chronological order. In each line print x — the index number of the monster in the current queue which eats and, separated by space, the symbol 'L' if the monster which stays the x-th in the queue eats the monster in front of him, or 'R' if the monster which stays the x-th in the queue eats the monster behind him. After each eating the queue is enumerated again.
When one monster eats another the queue decreases. If there are several answers, print any of them.
Examples
Input
6
1 2 2 2 1 2
2
5 5
Output
YES
2 L
1 R
4 L
3 L
Input
5
1 2 3 4 5
1
15
Output
YES
5 L
4 L
3 L
2 L
Input
5
1 1 1 3 3
3
2 1 6
Output
NO
Note
In the first example, initially there were n = 6 monsters, their weights are [1, 2, 2, 2, 1, 2] (in order of queue from the first monster to the last monster). The final queue should be [5, 5]. The following sequence of eatings leads to the final queue:
* the second monster eats the monster to the left (i.e. the first monster), queue becomes [3, 2, 2, 1, 2];
* the first monster (note, it was the second on the previous step) eats the monster to the right (i.e. the second monster), queue becomes [5, 2, 1, 2];
* the fourth monster eats the mosnter to the left (i.e. the third monster), queue becomes [5, 2, 3];
* the finally, the third monster eats the monster to the left (i.e. the second monster), queue becomes [5, 5].
Note that for each step the output contains numbers of the monsters in their current order in the queue.
Submitted Solution:
```
import sys
n = int(input())
ta = input().split()
a = [int(x) for x in ta]
m = int(input())
tb = input().split()
b = [int(x) for x in tb]
sum1,sum2 = 0,0
for i in a:
sum1 += i
for i in b:
sum2 += i
if sum1 != sum2:
print('NO')
sys.exit(0)
s = []
idx = 0
for i in range(m):
t = b[i]
oo = idx
mm = idx
while t > 0:
t -= a[idx]
if a[mm] < a[idx]:
mm = idx
idx += 1
if t < 0:
print('NO')
sys.exit(0)
if mm == oo:
while mm+1<idx and a[mm]==a[mm+1]:
mm = mm+1
flag = 0
if mm-1>=oo and a[mm]>a[mm-1]:
flag = 1
elif mm+1<idx and a[mm]>a[mm+1]:
flag = 2
elif idx-oo == 1:
continue
if flag == 0:
print('NO')
sys.exit(0)
elif flag == 1:
for x in range(mm,oo,-1):
s.append([x-oo+i,'L'])
for x in range(mm,idx-1):
s.append([i,'R'])
elif flag == 2:
for x in range(mm,idx-1):
s.append([mm-oo+i,'R'])
for x in range(mm,oo,-1):
s.append([x-oo+i,'L'])
print('YES')
for x in s:
print(str(x[0]+1)+' '+str(x[1]))
``` | instruction | 0 | 62,790 | 9 | 125,580 |
Yes | output | 1 | 62,790 | 9 | 125,581 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
There was an epidemic in Monstropolis and all monsters became sick. To recover, all monsters lined up in queue for an appointment to the only doctor in the city.
Soon, monsters became hungry and began to eat each other.
One monster can eat other monster if its weight is strictly greater than the weight of the monster being eaten, and they stand in the queue next to each other. Monsters eat each other instantly. There are no monsters which are being eaten at the same moment. After the monster A eats the monster B, the weight of the monster A increases by the weight of the eaten monster B. In result of such eating the length of the queue decreases by one, all monsters after the eaten one step forward so that there is no empty places in the queue again. A monster can eat several monsters one after another. Initially there were n monsters in the queue, the i-th of which had weight ai.
For example, if weights are [1, 2, 2, 2, 1, 2] (in order of queue, monsters are numbered from 1 to 6 from left to right) then some of the options are:
1. the first monster can't eat the second monster because a1 = 1 is not greater than a2 = 2;
2. the second monster can't eat the third monster because a2 = 2 is not greater than a3 = 2;
3. the second monster can't eat the fifth monster because they are not neighbors;
4. the second monster can eat the first monster, the queue will be transformed to [3, 2, 2, 1, 2].
After some time, someone said a good joke and all monsters recovered. At that moment there were k (k ≤ n) monsters in the queue, the j-th of which had weight bj. Both sequences (a and b) contain the weights of the monsters in the order from the first to the last.
You are required to provide one of the possible orders of eating monsters which led to the current queue, or to determine that this could not happen. Assume that the doctor didn't make any appointments while monsters were eating each other.
Input
The first line contains single integer n (1 ≤ n ≤ 500) — the number of monsters in the initial queue.
The second line contains n integers a1, a2, ..., an (1 ≤ ai ≤ 106) — the initial weights of the monsters.
The third line contains single integer k (1 ≤ k ≤ n) — the number of monsters in the queue after the joke.
The fourth line contains k integers b1, b2, ..., bk (1 ≤ bj ≤ 5·108) — the weights of the monsters after the joke.
Monsters are listed in the order from the beginning of the queue to the end.
Output
In case if no actions could lead to the final queue, print "NO" (without quotes) in the only line.
Otherwise print "YES" (without quotes) in the first line. In the next n - k lines print actions in the chronological order. In each line print x — the index number of the monster in the current queue which eats and, separated by space, the symbol 'L' if the monster which stays the x-th in the queue eats the monster in front of him, or 'R' if the monster which stays the x-th in the queue eats the monster behind him. After each eating the queue is enumerated again.
When one monster eats another the queue decreases. If there are several answers, print any of them.
Examples
Input
6
1 2 2 2 1 2
2
5 5
Output
YES
2 L
1 R
4 L
3 L
Input
5
1 2 3 4 5
1
15
Output
YES
5 L
4 L
3 L
2 L
Input
5
1 1 1 3 3
3
2 1 6
Output
NO
Note
In the first example, initially there were n = 6 monsters, their weights are [1, 2, 2, 2, 1, 2] (in order of queue from the first monster to the last monster). The final queue should be [5, 5]. The following sequence of eatings leads to the final queue:
* the second monster eats the monster to the left (i.e. the first monster), queue becomes [3, 2, 2, 1, 2];
* the first monster (note, it was the second on the previous step) eats the monster to the right (i.e. the second monster), queue becomes [5, 2, 1, 2];
* the fourth monster eats the mosnter to the left (i.e. the third monster), queue becomes [5, 2, 3];
* the finally, the third monster eats the monster to the left (i.e. the second monster), queue becomes [5, 5].
Note that for each step the output contains numbers of the monsters in their current order in the queue.
Submitted Solution:
```
n = int(input())
before = list(map(int, input().split()))
kk = int(input())
after = list(map(int, input().split()))
ans = []
if sum(before) != sum(after):
print('NO')
exit()
for i in range(kk):
need = after[i]
s = 0
j = i
while j < len(before) and s < need:
s += before[j]
j += 1
if s != need:
print('NO')
exit()
#print(before)
#print(i, j)
for k in range(j - i - 1):
#print(before, i, j - k + i)
'''ind = before.index(max(before[i:j - k + i]))
if ind > i and before[ind] > before[ind - 1]:
ans.append((ind + 1, 'L'))
before[ind] += before[ind - 1]
before = before[:ind - 1] + before[ind:]
elif ind < j - k + i - 1 and before[ind] > before[ind + 1]:
ans.append((ind + 1, 'R'))
before[ind] += before[ind + 1]
before = before[:ind + 1] + before[ind + 2:]'''
m = max(before[i:j - k])
for ind in range(i, j - k):
if before[ind] == m:
if ind > i and before[ind] > before[ind - 1]:
ans.append((ind + 1, 'L'))
before[ind] += before[ind - 1]
before = before[:ind - 1] + before[ind:]
break
elif ind < j - k - 1 and before[ind] > before[ind + 1]:
ans.append((ind + 1, 'R'))
before[ind] += before[ind + 1]
before = before[:ind + 1] + before[ind + 2:]
break
else:
print('NO')
exit()
#print(before)
if len(ans) == n - kk:
print('YES')
for i in ans:
print(*i)
else:
print('NO')
``` | instruction | 0 | 62,791 | 9 | 125,582 |
Yes | output | 1 | 62,791 | 9 | 125,583 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
There was an epidemic in Monstropolis and all monsters became sick. To recover, all monsters lined up in queue for an appointment to the only doctor in the city.
Soon, monsters became hungry and began to eat each other.
One monster can eat other monster if its weight is strictly greater than the weight of the monster being eaten, and they stand in the queue next to each other. Monsters eat each other instantly. There are no monsters which are being eaten at the same moment. After the monster A eats the monster B, the weight of the monster A increases by the weight of the eaten monster B. In result of such eating the length of the queue decreases by one, all monsters after the eaten one step forward so that there is no empty places in the queue again. A monster can eat several monsters one after another. Initially there were n monsters in the queue, the i-th of which had weight ai.
For example, if weights are [1, 2, 2, 2, 1, 2] (in order of queue, monsters are numbered from 1 to 6 from left to right) then some of the options are:
1. the first monster can't eat the second monster because a1 = 1 is not greater than a2 = 2;
2. the second monster can't eat the third monster because a2 = 2 is not greater than a3 = 2;
3. the second monster can't eat the fifth monster because they are not neighbors;
4. the second monster can eat the first monster, the queue will be transformed to [3, 2, 2, 1, 2].
After some time, someone said a good joke and all monsters recovered. At that moment there were k (k ≤ n) monsters in the queue, the j-th of which had weight bj. Both sequences (a and b) contain the weights of the monsters in the order from the first to the last.
You are required to provide one of the possible orders of eating monsters which led to the current queue, or to determine that this could not happen. Assume that the doctor didn't make any appointments while monsters were eating each other.
Input
The first line contains single integer n (1 ≤ n ≤ 500) — the number of monsters in the initial queue.
The second line contains n integers a1, a2, ..., an (1 ≤ ai ≤ 106) — the initial weights of the monsters.
The third line contains single integer k (1 ≤ k ≤ n) — the number of monsters in the queue after the joke.
The fourth line contains k integers b1, b2, ..., bk (1 ≤ bj ≤ 5·108) — the weights of the monsters after the joke.
Monsters are listed in the order from the beginning of the queue to the end.
Output
In case if no actions could lead to the final queue, print "NO" (without quotes) in the only line.
Otherwise print "YES" (without quotes) in the first line. In the next n - k lines print actions in the chronological order. In each line print x — the index number of the monster in the current queue which eats and, separated by space, the symbol 'L' if the monster which stays the x-th in the queue eats the monster in front of him, or 'R' if the monster which stays the x-th in the queue eats the monster behind him. After each eating the queue is enumerated again.
When one monster eats another the queue decreases. If there are several answers, print any of them.
Examples
Input
6
1 2 2 2 1 2
2
5 5
Output
YES
2 L
1 R
4 L
3 L
Input
5
1 2 3 4 5
1
15
Output
YES
5 L
4 L
3 L
2 L
Input
5
1 1 1 3 3
3
2 1 6
Output
NO
Note
In the first example, initially there were n = 6 monsters, their weights are [1, 2, 2, 2, 1, 2] (in order of queue from the first monster to the last monster). The final queue should be [5, 5]. The following sequence of eatings leads to the final queue:
* the second monster eats the monster to the left (i.e. the first monster), queue becomes [3, 2, 2, 1, 2];
* the first monster (note, it was the second on the previous step) eats the monster to the right (i.e. the second monster), queue becomes [5, 2, 1, 2];
* the fourth monster eats the mosnter to the left (i.e. the third monster), queue becomes [5, 2, 3];
* the finally, the third monster eats the monster to the left (i.e. the second monster), queue becomes [5, 5].
Note that for each step the output contains numbers of the monsters in their current order in the queue.
Submitted Solution:
```
def takefirst(a, s):
curs = 0
for i in range(len(a)):
curs += a[i]
if curs == s:
return i
if curs > s:
return -1
return -1
def maxid(a):
if len(a) == 1: return 0
m = max(a)
if a[0] == m:
if a[1] < m: return 0
if a[-1] == m:
if a[-2] < m: return len(a)-1
for i in range(1,len(a)-1):
if a[i] == m:
if a[i+1] < m or a[i-1] < m:
return i
return a.index(m)
def maxid1(a):
m = a[0]
mid = 0
for i in range(len(a)):
if m < a[i]:
m = a[i]
mid = i
continue
if m == a[i]:
mid = i
if mid == len(a) - 1:
for i in range(len(a)):
if a[i] == m:
return i
return mid
n = int(input())
a = list(map(int,input().split()))
m = int(input())
b = list(map(int,input().split()))
step = []
flag = True
o = 0
for i in b:
take = takefirst(a,i)
if take == -1:
#NO
flag = False
break
else:
considering = a[:take+1]
a = a[take+1:]
#print(considering)
if len(considering) <= 1:
o += 1
continue
biggest = maxid(considering)
ii = biggest
#print(ii,take)
#print("a",a)
if biggest < take and considering[biggest] > considering[biggest+1]:
while(ii < take):
step.append(str(biggest+1+o) + " R")
ii += 1
while(biggest > 0):
step.append(str(biggest+1+o) + " L")
biggest -= 1
elif biggest > 0 and considering[biggest] > considering[biggest-1]:
while(biggest > 0):
step.append(str(biggest+1+o) + " L")
biggest -= 1
while(ii < take):
step.append(str(1+o) + " R")
ii += 1
elif biggest == 0 and considering[biggest] > considering[biggest+1]:
while(ii < take):
step.append(str(biggest+1+o) + " R")
ii += 1
elif biggest == take and considering[biggest] > considering[biggest-1]:
while(biggest > 0):
step.append(str(biggest+1+o) + " L")
biggest -= 1
else:
flag = False
#print("step", step)
o += 1
if len(a) > 0:
flag = False
if not flag:
print("NO")
else:
print("YES")
if len(step) > 0:
print("\n".join(step))
``` | instruction | 0 | 62,792 | 9 | 125,584 |
Yes | output | 1 | 62,792 | 9 | 125,585 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
There was an epidemic in Monstropolis and all monsters became sick. To recover, all monsters lined up in queue for an appointment to the only doctor in the city.
Soon, monsters became hungry and began to eat each other.
One monster can eat other monster if its weight is strictly greater than the weight of the monster being eaten, and they stand in the queue next to each other. Monsters eat each other instantly. There are no monsters which are being eaten at the same moment. After the monster A eats the monster B, the weight of the monster A increases by the weight of the eaten monster B. In result of such eating the length of the queue decreases by one, all monsters after the eaten one step forward so that there is no empty places in the queue again. A monster can eat several monsters one after another. Initially there were n monsters in the queue, the i-th of which had weight ai.
For example, if weights are [1, 2, 2, 2, 1, 2] (in order of queue, monsters are numbered from 1 to 6 from left to right) then some of the options are:
1. the first monster can't eat the second monster because a1 = 1 is not greater than a2 = 2;
2. the second monster can't eat the third monster because a2 = 2 is not greater than a3 = 2;
3. the second monster can't eat the fifth monster because they are not neighbors;
4. the second monster can eat the first monster, the queue will be transformed to [3, 2, 2, 1, 2].
After some time, someone said a good joke and all monsters recovered. At that moment there were k (k ≤ n) monsters in the queue, the j-th of which had weight bj. Both sequences (a and b) contain the weights of the monsters in the order from the first to the last.
You are required to provide one of the possible orders of eating monsters which led to the current queue, or to determine that this could not happen. Assume that the doctor didn't make any appointments while monsters were eating each other.
Input
The first line contains single integer n (1 ≤ n ≤ 500) — the number of monsters in the initial queue.
The second line contains n integers a1, a2, ..., an (1 ≤ ai ≤ 106) — the initial weights of the monsters.
The third line contains single integer k (1 ≤ k ≤ n) — the number of monsters in the queue after the joke.
The fourth line contains k integers b1, b2, ..., bk (1 ≤ bj ≤ 5·108) — the weights of the monsters after the joke.
Monsters are listed in the order from the beginning of the queue to the end.
Output
In case if no actions could lead to the final queue, print "NO" (without quotes) in the only line.
Otherwise print "YES" (without quotes) in the first line. In the next n - k lines print actions in the chronological order. In each line print x — the index number of the monster in the current queue which eats and, separated by space, the symbol 'L' if the monster which stays the x-th in the queue eats the monster in front of him, or 'R' if the monster which stays the x-th in the queue eats the monster behind him. After each eating the queue is enumerated again.
When one monster eats another the queue decreases. If there are several answers, print any of them.
Examples
Input
6
1 2 2 2 1 2
2
5 5
Output
YES
2 L
1 R
4 L
3 L
Input
5
1 2 3 4 5
1
15
Output
YES
5 L
4 L
3 L
2 L
Input
5
1 1 1 3 3
3
2 1 6
Output
NO
Note
In the first example, initially there were n = 6 monsters, their weights are [1, 2, 2, 2, 1, 2] (in order of queue from the first monster to the last monster). The final queue should be [5, 5]. The following sequence of eatings leads to the final queue:
* the second monster eats the monster to the left (i.e. the first monster), queue becomes [3, 2, 2, 1, 2];
* the first monster (note, it was the second on the previous step) eats the monster to the right (i.e. the second monster), queue becomes [5, 2, 1, 2];
* the fourth monster eats the mosnter to the left (i.e. the third monster), queue becomes [5, 2, 3];
* the finally, the third monster eats the monster to the left (i.e. the second monster), queue becomes [5, 5].
Note that for each step the output contains numbers of the monsters in their current order in the queue.
Submitted Solution:
```
#!/usr/bin/env python3
n = int(input())
a = list(map(int, input().split()))
k = int(input())
b = list(map(int, input().split()))
s = 0
j = 0
ae = []
for i in range(n):
s += a[i]
if s == b[j]:
ae.append(i)
j += 1
s = 0
start = 0
maxi = []
for i in range(k):
mm = 0
if ae[i] != start:
if min(a[start:ae[i]+1]) == max(a[start:ae[i]+1]):
print("NO")
exit()
for j in range(start, ae[i]):
if a[j] == a[j+1]:
continue
if mm < a[j] + a[j+1]:
mm = a[j] + a[j+1]
maxi_temp = j
maxi.append(maxi_temp)
else:
maxi.append(start)
start = ae[i]+1
ostr = []
for i in range(k-1, -1, -1):
if i == 0:
start = 0
else:
start = ae[i-1] + 1
if b[i] == 1:
break
else:
mm = max(a[maxi[i]], a[maxi[i]+1])
if mm == a[maxi[i]]:
for j in range(maxi[i], ae[i]):
ostr.append(str(maxi[i]+1) + " R")
for j in range(maxi[i], start, -1):
ostr.append(str(j) + " L")
else:
ostr.append(str(maxi[i]+2) + " L")
for j in range(maxi[i]+1, ae[i]):
ostr.append(str(maxi[i]+1) + " R")
for j in range(maxi[i], start, -1):
ostr.append(str(j+1) + " L")
for ss in ostr:
print(ss)
``` | instruction | 0 | 62,793 | 9 | 125,586 |
No | output | 1 | 62,793 | 9 | 125,587 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
There was an epidemic in Monstropolis and all monsters became sick. To recover, all monsters lined up in queue for an appointment to the only doctor in the city.
Soon, monsters became hungry and began to eat each other.
One monster can eat other monster if its weight is strictly greater than the weight of the monster being eaten, and they stand in the queue next to each other. Monsters eat each other instantly. There are no monsters which are being eaten at the same moment. After the monster A eats the monster B, the weight of the monster A increases by the weight of the eaten monster B. In result of such eating the length of the queue decreases by one, all monsters after the eaten one step forward so that there is no empty places in the queue again. A monster can eat several monsters one after another. Initially there were n monsters in the queue, the i-th of which had weight ai.
For example, if weights are [1, 2, 2, 2, 1, 2] (in order of queue, monsters are numbered from 1 to 6 from left to right) then some of the options are:
1. the first monster can't eat the second monster because a1 = 1 is not greater than a2 = 2;
2. the second monster can't eat the third monster because a2 = 2 is not greater than a3 = 2;
3. the second monster can't eat the fifth monster because they are not neighbors;
4. the second monster can eat the first monster, the queue will be transformed to [3, 2, 2, 1, 2].
After some time, someone said a good joke and all monsters recovered. At that moment there were k (k ≤ n) monsters in the queue, the j-th of which had weight bj. Both sequences (a and b) contain the weights of the monsters in the order from the first to the last.
You are required to provide one of the possible orders of eating monsters which led to the current queue, or to determine that this could not happen. Assume that the doctor didn't make any appointments while monsters were eating each other.
Input
The first line contains single integer n (1 ≤ n ≤ 500) — the number of monsters in the initial queue.
The second line contains n integers a1, a2, ..., an (1 ≤ ai ≤ 106) — the initial weights of the monsters.
The third line contains single integer k (1 ≤ k ≤ n) — the number of monsters in the queue after the joke.
The fourth line contains k integers b1, b2, ..., bk (1 ≤ bj ≤ 5·108) — the weights of the monsters after the joke.
Monsters are listed in the order from the beginning of the queue to the end.
Output
In case if no actions could lead to the final queue, print "NO" (without quotes) in the only line.
Otherwise print "YES" (without quotes) in the first line. In the next n - k lines print actions in the chronological order. In each line print x — the index number of the monster in the current queue which eats and, separated by space, the symbol 'L' if the monster which stays the x-th in the queue eats the monster in front of him, or 'R' if the monster which stays the x-th in the queue eats the monster behind him. After each eating the queue is enumerated again.
When one monster eats another the queue decreases. If there are several answers, print any of them.
Examples
Input
6
1 2 2 2 1 2
2
5 5
Output
YES
2 L
1 R
4 L
3 L
Input
5
1 2 3 4 5
1
15
Output
YES
5 L
4 L
3 L
2 L
Input
5
1 1 1 3 3
3
2 1 6
Output
NO
Note
In the first example, initially there were n = 6 monsters, their weights are [1, 2, 2, 2, 1, 2] (in order of queue from the first monster to the last monster). The final queue should be [5, 5]. The following sequence of eatings leads to the final queue:
* the second monster eats the monster to the left (i.e. the first monster), queue becomes [3, 2, 2, 1, 2];
* the first monster (note, it was the second on the previous step) eats the monster to the right (i.e. the second monster), queue becomes [5, 2, 1, 2];
* the fourth monster eats the mosnter to the left (i.e. the third monster), queue becomes [5, 2, 3];
* the finally, the third monster eats the monster to the left (i.e. the second monster), queue becomes [5, 5].
Note that for each step the output contains numbers of the monsters in their current order in the queue.
Submitted Solution:
```
import sys
def testBeginning(Monsters, finalMonster):
sumMonsters=0
for i in range(0,len(Monsters)):
sumMonsters+=Monsters[i]
if(sumMonsters==finalMonster):
return i
elif(sumMonsters>finalMonster):
return -1
else:
continue
def MonsterEatingProcess(Monsters,process,count):
for i in range(0,len(Monsters)):
try:
if(Monsters[i]>Monsters[i+1]):
#print("before: ",Monsters)
Monsters2=Monsters[:i]+[int(Monsters[i])+int(Monsters[i+1])]+Monsters[i+2:]
#print("after: ",Monsters2)
process.append(i+1+count)
process.append("R")
process=MonsterEatingProcess(Monsters2,process,count)
break
except:
none=1
try:
if(Monsters[i]>Monsters[i-1]):
Monsters2=Monsters[:i-1]+[int(Monsters[i-1])+int(Monsters[i])]+Monsters[i+1:]
process.append(i+1+count)
process.append("L")
process=MonsterEatingProcess(Monsters2,process,count)
break
except:
none=1
return process
#file=open("epidemic.txt",'r')
#numMonsters=file.readline().strip()
#Monsters=file.readline().strip().split(" ")
#numFinalMonsters=file.readline().strip()
#finalMonsters=file.readline().strip().split(" ")
numMonsters=sys.stdin.readline().strip()
Monsters=sys.stdin.readline().strip().split(" ")
numFinalMonsters=sys.stdin.readline().strip()
finalMonsters=sys.stdin.readline().strip().split(" ")
for i in range(0,len(Monsters)):
Monsters[i]=int(Monsters[i])
for i in range(0,len(finalMonsters)):
finalMonsters[i]=int(finalMonsters[i])
process=[]
count=0
while True:
combined=testBeginning(Monsters,finalMonsters[0])
if(combined==-1):
print("NO")
break
else:
process=MonsterEatingProcess(Monsters[:combined+1],process,count)
Monsters=Monsters[combined+1:]
finalMonsters=finalMonsters[1:]
count+=1
if(len(Monsters)==0):
print("YES")
for i in range(0,len(process),2):
print(str(process[i])+" "+str(process[i+1]))
break
#sys.stdout.write(answer)
``` | instruction | 0 | 62,794 | 9 | 125,588 |
No | output | 1 | 62,794 | 9 | 125,589 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
There was an epidemic in Monstropolis and all monsters became sick. To recover, all monsters lined up in queue for an appointment to the only doctor in the city.
Soon, monsters became hungry and began to eat each other.
One monster can eat other monster if its weight is strictly greater than the weight of the monster being eaten, and they stand in the queue next to each other. Monsters eat each other instantly. There are no monsters which are being eaten at the same moment. After the monster A eats the monster B, the weight of the monster A increases by the weight of the eaten monster B. In result of such eating the length of the queue decreases by one, all monsters after the eaten one step forward so that there is no empty places in the queue again. A monster can eat several monsters one after another. Initially there were n monsters in the queue, the i-th of which had weight ai.
For example, if weights are [1, 2, 2, 2, 1, 2] (in order of queue, monsters are numbered from 1 to 6 from left to right) then some of the options are:
1. the first monster can't eat the second monster because a1 = 1 is not greater than a2 = 2;
2. the second monster can't eat the third monster because a2 = 2 is not greater than a3 = 2;
3. the second monster can't eat the fifth monster because they are not neighbors;
4. the second monster can eat the first monster, the queue will be transformed to [3, 2, 2, 1, 2].
After some time, someone said a good joke and all monsters recovered. At that moment there were k (k ≤ n) monsters in the queue, the j-th of which had weight bj. Both sequences (a and b) contain the weights of the monsters in the order from the first to the last.
You are required to provide one of the possible orders of eating monsters which led to the current queue, or to determine that this could not happen. Assume that the doctor didn't make any appointments while monsters were eating each other.
Input
The first line contains single integer n (1 ≤ n ≤ 500) — the number of monsters in the initial queue.
The second line contains n integers a1, a2, ..., an (1 ≤ ai ≤ 106) — the initial weights of the monsters.
The third line contains single integer k (1 ≤ k ≤ n) — the number of monsters in the queue after the joke.
The fourth line contains k integers b1, b2, ..., bk (1 ≤ bj ≤ 5·108) — the weights of the monsters after the joke.
Monsters are listed in the order from the beginning of the queue to the end.
Output
In case if no actions could lead to the final queue, print "NO" (without quotes) in the only line.
Otherwise print "YES" (without quotes) in the first line. In the next n - k lines print actions in the chronological order. In each line print x — the index number of the monster in the current queue which eats and, separated by space, the symbol 'L' if the monster which stays the x-th in the queue eats the monster in front of him, or 'R' if the monster which stays the x-th in the queue eats the monster behind him. After each eating the queue is enumerated again.
When one monster eats another the queue decreases. If there are several answers, print any of them.
Examples
Input
6
1 2 2 2 1 2
2
5 5
Output
YES
2 L
1 R
4 L
3 L
Input
5
1 2 3 4 5
1
15
Output
YES
5 L
4 L
3 L
2 L
Input
5
1 1 1 3 3
3
2 1 6
Output
NO
Note
In the first example, initially there were n = 6 monsters, their weights are [1, 2, 2, 2, 1, 2] (in order of queue from the first monster to the last monster). The final queue should be [5, 5]. The following sequence of eatings leads to the final queue:
* the second monster eats the monster to the left (i.e. the first monster), queue becomes [3, 2, 2, 1, 2];
* the first monster (note, it was the second on the previous step) eats the monster to the right (i.e. the second monster), queue becomes [5, 2, 1, 2];
* the fourth monster eats the mosnter to the left (i.e. the third monster), queue becomes [5, 2, 3];
* the finally, the third monster eats the monster to the left (i.e. the second monster), queue becomes [5, 5].
Note that for each step the output contains numbers of the monsters in their current order in the queue.
Submitted Solution:
```
an=int(input())
a=input().split()
bn=int(input())
b=input().split()
for i in range(an):
a[i]=int(a[i])
for i in range(bn):
b[i]=int(b[i])
##########################
idd=0
res=[-1]
t=0
j=0
for i in range(an):
t+=a[i]
if t<b[j]:
continue
elif t==b[j]:
res.append(i)
t=0
j+=1
else:
idd=1
print("NO")
break
###################################
if idd==0:
RES=[]
for i in range(len(res)-1):
RES.append(a[res[i]+1:res[i+1]+1])
res=[]
ll=0
for c in RES:
if c.count(c[0])!=len(c):
for i in range(len(c)-1):
####
X=0
for y in range(1,len(c)):
if c[y]==c[0]:
X=y
else:
break
####
if c[X]>c[X+1]:
res.append(str(X+1+ll)+" R") # X real index
c[X]+=c[X+1]
c.pop(X+1)
else:
res.append(str(X+2+ll)+" L") # X+1 real index
c[X+1]+=c[X]
c.pop(X)
else:
print("NO")
break
ll+=1
else:
print("YES")
for i in range(len(res)):
print(res[i])
``` | instruction | 0 | 62,795 | 9 | 125,590 |
No | output | 1 | 62,795 | 9 | 125,591 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
There was an epidemic in Monstropolis and all monsters became sick. To recover, all monsters lined up in queue for an appointment to the only doctor in the city.
Soon, monsters became hungry and began to eat each other.
One monster can eat other monster if its weight is strictly greater than the weight of the monster being eaten, and they stand in the queue next to each other. Monsters eat each other instantly. There are no monsters which are being eaten at the same moment. After the monster A eats the monster B, the weight of the monster A increases by the weight of the eaten monster B. In result of such eating the length of the queue decreases by one, all monsters after the eaten one step forward so that there is no empty places in the queue again. A monster can eat several monsters one after another. Initially there were n monsters in the queue, the i-th of which had weight ai.
For example, if weights are [1, 2, 2, 2, 1, 2] (in order of queue, monsters are numbered from 1 to 6 from left to right) then some of the options are:
1. the first monster can't eat the second monster because a1 = 1 is not greater than a2 = 2;
2. the second monster can't eat the third monster because a2 = 2 is not greater than a3 = 2;
3. the second monster can't eat the fifth monster because they are not neighbors;
4. the second monster can eat the first monster, the queue will be transformed to [3, 2, 2, 1, 2].
After some time, someone said a good joke and all monsters recovered. At that moment there were k (k ≤ n) monsters in the queue, the j-th of which had weight bj. Both sequences (a and b) contain the weights of the monsters in the order from the first to the last.
You are required to provide one of the possible orders of eating monsters which led to the current queue, or to determine that this could not happen. Assume that the doctor didn't make any appointments while monsters were eating each other.
Input
The first line contains single integer n (1 ≤ n ≤ 500) — the number of monsters in the initial queue.
The second line contains n integers a1, a2, ..., an (1 ≤ ai ≤ 106) — the initial weights of the monsters.
The third line contains single integer k (1 ≤ k ≤ n) — the number of monsters in the queue after the joke.
The fourth line contains k integers b1, b2, ..., bk (1 ≤ bj ≤ 5·108) — the weights of the monsters after the joke.
Monsters are listed in the order from the beginning of the queue to the end.
Output
In case if no actions could lead to the final queue, print "NO" (without quotes) in the only line.
Otherwise print "YES" (without quotes) in the first line. In the next n - k lines print actions in the chronological order. In each line print x — the index number of the monster in the current queue which eats and, separated by space, the symbol 'L' if the monster which stays the x-th in the queue eats the monster in front of him, or 'R' if the monster which stays the x-th in the queue eats the monster behind him. After each eating the queue is enumerated again.
When one monster eats another the queue decreases. If there are several answers, print any of them.
Examples
Input
6
1 2 2 2 1 2
2
5 5
Output
YES
2 L
1 R
4 L
3 L
Input
5
1 2 3 4 5
1
15
Output
YES
5 L
4 L
3 L
2 L
Input
5
1 1 1 3 3
3
2 1 6
Output
NO
Note
In the first example, initially there were n = 6 monsters, their weights are [1, 2, 2, 2, 1, 2] (in order of queue from the first monster to the last monster). The final queue should be [5, 5]. The following sequence of eatings leads to the final queue:
* the second monster eats the monster to the left (i.e. the first monster), queue becomes [3, 2, 2, 1, 2];
* the first monster (note, it was the second on the previous step) eats the monster to the right (i.e. the second monster), queue becomes [5, 2, 1, 2];
* the fourth monster eats the mosnter to the left (i.e. the third monster), queue becomes [5, 2, 3];
* the finally, the third monster eats the monster to the left (i.e. the second monster), queue becomes [5, 5].
Note that for each step the output contains numbers of the monsters in their current order in the queue.
Submitted Solution:
```
n = int(input());
a = [int(x) for x in input().split()];
k = int(input());
b = [int(x) for x in input().split()];
partial_sums = [0] * n;
partial_sums[0] = a[0];
for i in range(1, n):
partial_sums[i] = partial_sums[i - 1] + a[i];
d = [[False for x in range(k + 1)] for i in range(n + 1)];
ans = [[0] * (k + 1) for i in range(n + 1)];
d[0][0] = True;
for i in range(1, n + 1):
for j in range(1, min(i, k) + 1):
for r in range(1, i - j + 2):
sub_sum = partial_sums[i - 1] - partial_sums[i - r] + a[i - r];
can_be_used = ((sub_sum != a[i - r] * r) or (r == 1));
check = (can_be_used and ((partial_sums[i - 1] - partial_sums[i - r] + a[i - r]) == b[j - 1]));
if d[i - r][j - 1] and check:
d[i][j] = True;
ans[i][j] = r;
break;
if not d[n][k]:
print("NO");
else:
print("YES");
curn = n;
curk = k;
while curn > 0:
# print result
maxval = -1;
maxindx = curn;
for i in range(curn - ans[curn][curk] + 1, curn + 1):
if a[i - 1] > maxval:
maxval = a[i - 1];
maxindx = i;
left_cnt = maxindx - curn + ans[curn][curk] - 1;
right_cnt = curn - maxindx;
for i in range(right_cnt):
print("%d R" % maxindx);
for i in range(left_cnt):
print("%d L" % maxindx);
maxindx -= 1;
# next iteration
curn -= ans[curn][curk];
curk -= 1;
``` | instruction | 0 | 62,796 | 9 | 125,592 |
No | output | 1 | 62,796 | 9 | 125,593 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
— I... I survived.
— Welcome home, Chtholly.
— I kept my promise...
— I made it... I really made it!
After several days of fighting, Chtholly Nota Seniorious miraculously returned from the fierce battle.
As promised, Willem is now baking butter cake for her.
However, although Willem is skilled in making dessert, he rarely bakes butter cake.
This time, Willem made a big mistake — he accidentally broke the oven!
Fortunately, Chtholly decided to help him.
Willem puts n cakes on a roll, cakes are numbered from 1 to n, the i-th cake needs ai seconds of baking.
Willem needs Chtholly to do m operations to bake the cakes.
Operation 1: 1 l r x
Willem asks Chtholly to check each cake in the range [l, r], if the cake needs to be baked for more than x seconds, he would bake it for x seconds and put it back in its place. More precisely, for every i in range [l, r], if ai is strictly more than x, ai becomes equal ai - x.
Operation 2: 2 l r x
Willem asks Chtholly to count the number of cakes in the range [l, r] that needs to be cooked for exactly x seconds. More formally you should find number of such i in range [l, r], that ai = x.
Input
The first line contains two integers n and m (1 ≤ n, m ≤ 105).
The second line contains n integers, i-th of them is ai (1 ≤ ai ≤ 105).
The next m lines are the m operations described above. It is guaranteed that 1 ≤ l ≤ r ≤ n and 1 ≤ x ≤ 105.
Output
For each operation of the second type, print the answer.
Examples
Input
5 6
1 5 5 5 8
2 2 5 5
1 2 4 3
2 2 5 2
2 2 5 5
1 3 5 1
2 1 5 1
Output
3
3
0
3
Input
7 7
1 9 2 6 8 1 7
2 1 7 1
2 2 5 2
1 4 7 7
2 2 4 2
1 3 4 5
2 3 3 3
2 3 7 2
Output
2
1
1
0
1
Input
8 13
75 85 88 100 105 120 122 128
1 1 8 70
2 3 8 30
1 3 8 3
2 2 5 15
1 2 4 10
2 1 5 5
1 2 7 27
2 1 5 5
1 3 7 12
1 1 7 4
2 1 8 1
1 4 8 5
2 1 8 1
Output
1
2
3
4
5
6
Submitted Solution:
```
print(114)
``` | instruction | 0 | 62,841 | 9 | 125,682 |
No | output | 1 | 62,841 | 9 | 125,683 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
— I... I survived.
— Welcome home, Chtholly.
— I kept my promise...
— I made it... I really made it!
After several days of fighting, Chtholly Nota Seniorious miraculously returned from the fierce battle.
As promised, Willem is now baking butter cake for her.
However, although Willem is skilled in making dessert, he rarely bakes butter cake.
This time, Willem made a big mistake — he accidentally broke the oven!
Fortunately, Chtholly decided to help him.
Willem puts n cakes on a roll, cakes are numbered from 1 to n, the i-th cake needs ai seconds of baking.
Willem needs Chtholly to do m operations to bake the cakes.
Operation 1: 1 l r x
Willem asks Chtholly to check each cake in the range [l, r], if the cake needs to be baked for more than x seconds, he would bake it for x seconds and put it back in its place. More precisely, for every i in range [l, r], if ai is strictly more than x, ai becomes equal ai - x.
Operation 2: 2 l r x
Willem asks Chtholly to count the number of cakes in the range [l, r] that needs to be cooked for exactly x seconds. More formally you should find number of such i in range [l, r], that ai = x.
Input
The first line contains two integers n and m (1 ≤ n, m ≤ 105).
The second line contains n integers, i-th of them is ai (1 ≤ ai ≤ 105).
The next m lines are the m operations described above. It is guaranteed that 1 ≤ l ≤ r ≤ n and 1 ≤ x ≤ 105.
Output
For each operation of the second type, print the answer.
Examples
Input
5 6
1 5 5 5 8
2 2 5 5
1 2 4 3
2 2 5 2
2 2 5 5
1 3 5 1
2 1 5 1
Output
3
3
0
3
Input
7 7
1 9 2 6 8 1 7
2 1 7 1
2 2 5 2
1 4 7 7
2 2 4 2
1 3 4 5
2 3 3 3
2 3 7 2
Output
2
1
1
0
1
Input
8 13
75 85 88 100 105 120 122 128
1 1 8 70
2 3 8 30
1 3 8 3
2 2 5 15
1 2 4 10
2 1 5 5
1 2 7 27
2 1 5 5
1 3 7 12
1 1 7 4
2 1 8 1
1 4 8 5
2 1 8 1
Output
1
2
3
4
5
6
Submitted Solution:
```
def tkeInput():
cakesNum, operationsNum = [int(i) for i in input('n, m: '.strip()).strip().split(' ')]
# time for each cake
times = [int(i) for i in input('times: ').strip().split(' ')]
assert len(times) == cakesNum
cakesTimes = {}
for i in range(len(times)):
cakesTimes['c' + str(i+1)] = times[i]
operations = ()
for i in range(operationsNum):
operation = {}
operation['op'],operation['from'], operation['to'], operation['time'] = [int(i) for i in input('operation: ').strip().split(' ')]
operations += (operation,)
return cakesTimes, operations
# execute
def op_1(rng, time, cakesTimes):
rng = range(rng[0], rng[1] + 1)
for cake in rng:
cakeTime = cakesTimes['c' + str(cake)]
if cakeTime > time:
cakesTimes['c' + str(cake)] = cakeTime - time
return cakesTimes
# print
def op_2(rng, time, cakesTimes):
rng = range(rng[0], rng[1] + 1)
counter = 0
for cake in rng:
cakeTime = cakesTimes['c' + str(cake)]
if cakeTime == time:
counter += 1
print(counter)
def main():
cakesTimes, operations = tkeInput()
for operation in operations:
op = operation['op']
rng = (operation['from'], operation['to'])
time = operation['time']
if op == 1 :
op_1(rng, time, cakesTimes)
elif op == 2 :
op_2(rng, time, cakesTimes)
main()
``` | instruction | 0 | 62,842 | 9 | 125,684 |
No | output | 1 | 62,842 | 9 | 125,685 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
— I... I survived.
— Welcome home, Chtholly.
— I kept my promise...
— I made it... I really made it!
After several days of fighting, Chtholly Nota Seniorious miraculously returned from the fierce battle.
As promised, Willem is now baking butter cake for her.
However, although Willem is skilled in making dessert, he rarely bakes butter cake.
This time, Willem made a big mistake — he accidentally broke the oven!
Fortunately, Chtholly decided to help him.
Willem puts n cakes on a roll, cakes are numbered from 1 to n, the i-th cake needs ai seconds of baking.
Willem needs Chtholly to do m operations to bake the cakes.
Operation 1: 1 l r x
Willem asks Chtholly to check each cake in the range [l, r], if the cake needs to be baked for more than x seconds, he would bake it for x seconds and put it back in its place. More precisely, for every i in range [l, r], if ai is strictly more than x, ai becomes equal ai - x.
Operation 2: 2 l r x
Willem asks Chtholly to count the number of cakes in the range [l, r] that needs to be cooked for exactly x seconds. More formally you should find number of such i in range [l, r], that ai = x.
Input
The first line contains two integers n and m (1 ≤ n, m ≤ 105).
The second line contains n integers, i-th of them is ai (1 ≤ ai ≤ 105).
The next m lines are the m operations described above. It is guaranteed that 1 ≤ l ≤ r ≤ n and 1 ≤ x ≤ 105.
Output
For each operation of the second type, print the answer.
Examples
Input
5 6
1 5 5 5 8
2 2 5 5
1 2 4 3
2 2 5 2
2 2 5 5
1 3 5 1
2 1 5 1
Output
3
3
0
3
Input
7 7
1 9 2 6 8 1 7
2 1 7 1
2 2 5 2
1 4 7 7
2 2 4 2
1 3 4 5
2 3 3 3
2 3 7 2
Output
2
1
1
0
1
Input
8 13
75 85 88 100 105 120 122 128
1 1 8 70
2 3 8 30
1 3 8 3
2 2 5 15
1 2 4 10
2 1 5 5
1 2 7 27
2 1 5 5
1 3 7 12
1 1 7 4
2 1 8 1
1 4 8 5
2 1 8 1
Output
1
2
3
4
5
6
Submitted Solution:
```
def get_int(string, n):
i = j = k = 0
for s in string:
k += 1
for s in string:
if i == n - 1:
break
if s == ' ':
i += 1
j += 1
i = 0
while j < k:
if string[j] == ' ':
break
i = 10 * i + int(string[j])
j += 1
return i
def get_zcy(string):
strin = ''
for i in string:
strin = i + strin
return string + strin
x = input()
k = get_int(x, 1)
p = get_int(x, 2)
sum = 0
for i in range(1, k + 1):
y = f"{i}"
y = get_zcy(y)
sum += int(y)
print(sum % p)
``` | instruction | 0 | 62,843 | 9 | 125,686 |
No | output | 1 | 62,843 | 9 | 125,687 |
Provide a correct Python 3 solution for this coding contest problem.
There are N children, numbered 1, 2, \ldots, N.
They have decided to share K candies among themselves. Here, for each i (1 \leq i \leq N), Child i must receive between 0 and a_i candies (inclusive). Also, no candies should be left over.
Find the number of ways for them to share candies, modulo 10^9 + 7. Here, two ways are said to be different when there exists a child who receives a different number of candies.
Constraints
* All values in input are integers.
* 1 \leq N \leq 100
* 0 \leq K \leq 10^5
* 0 \leq a_i \leq K
Input
Input is given from Standard Input in the following format:
N K
a_1 a_2 \ldots a_N
Output
Print the number of ways for the children to share candies, modulo 10^9 + 7.
Examples
Input
3 4
1 2 3
Output
5
Input
1 10
9
Output
0
Input
2 0
0 0
Output
1
Input
4 100000
100000 100000 100000 100000
Output
665683269 | instruction | 0 | 62,934 | 9 | 125,868 |
"Correct Solution:
```
mod = 10 ** 9 + 7
N, K, *A = map(int, open(0).read().split())
dp = [1] + [0] * (K + 1)
for a in A:
for i in range(1, K + 1):
dp[i] += dp[i - 1]
for i in reversed(range(1, K + 1)):
dp[i] -= dp[max(0, i - a) - 1]
dp[i] %= mod
print(dp[K])
``` | output | 1 | 62,934 | 9 | 125,869 |
Provide a correct Python 3 solution for this coding contest problem.
There are N children, numbered 1, 2, \ldots, N.
They have decided to share K candies among themselves. Here, for each i (1 \leq i \leq N), Child i must receive between 0 and a_i candies (inclusive). Also, no candies should be left over.
Find the number of ways for them to share candies, modulo 10^9 + 7. Here, two ways are said to be different when there exists a child who receives a different number of candies.
Constraints
* All values in input are integers.
* 1 \leq N \leq 100
* 0 \leq K \leq 10^5
* 0 \leq a_i \leq K
Input
Input is given from Standard Input in the following format:
N K
a_1 a_2 \ldots a_N
Output
Print the number of ways for the children to share candies, modulo 10^9 + 7.
Examples
Input
3 4
1 2 3
Output
5
Input
1 10
9
Output
0
Input
2 0
0 0
Output
1
Input
4 100000
100000 100000 100000 100000
Output
665683269 | instruction | 0 | 62,935 | 9 | 125,870 |
"Correct Solution:
```
import sys
sys.setrecursionlimit(10 ** 6)
input = sys.stdin.readline
int1 = lambda x: int(x) - 1
p2D = lambda x: print(*x, sep="\n")
def main():
md = 10 ** 9 + 7
n, k = map(int, input().split())
aa = list(map(int, input().split()))
dp = [[0] * (k + 1) for _ in range(n + 1)]
dp[0][0] = 1
for i in range(n):
a = aa[i]
s = 0
for j in range(k + 1):
s += dp[i][j]
if j - a - 1 >= 0: s -= dp[i][j - a - 1]
s %= md
dp[i + 1][j] = s
# p2D(dp)
print(dp[n][k])
main()
``` | output | 1 | 62,935 | 9 | 125,871 |
Provide a correct Python 3 solution for this coding contest problem.
There are N children, numbered 1, 2, \ldots, N.
They have decided to share K candies among themselves. Here, for each i (1 \leq i \leq N), Child i must receive between 0 and a_i candies (inclusive). Also, no candies should be left over.
Find the number of ways for them to share candies, modulo 10^9 + 7. Here, two ways are said to be different when there exists a child who receives a different number of candies.
Constraints
* All values in input are integers.
* 1 \leq N \leq 100
* 0 \leq K \leq 10^5
* 0 \leq a_i \leq K
Input
Input is given from Standard Input in the following format:
N K
a_1 a_2 \ldots a_N
Output
Print the number of ways for the children to share candies, modulo 10^9 + 7.
Examples
Input
3 4
1 2 3
Output
5
Input
1 10
9
Output
0
Input
2 0
0 0
Output
1
Input
4 100000
100000 100000 100000 100000
Output
665683269 | instruction | 0 | 62,936 | 9 | 125,872 |
"Correct Solution:
```
n,k = map(int,input().split())
candies = list(map(int,input().split()))
dp = [0] * (k+1)
minimo = [1] * (k+2)
mod = 1e9 + 7
dp[0] = 1
minimo[0] = 0
for i in range(1, n + 1):
soma = [0] * (k+2)
for j in range(k+1):
dp[j] = (minimo[j+1] - minimo[max(0, j - min(k,candies[i-1]))]) % mod
soma[j+1] = (soma[j] + dp[j]) % mod
minimo = soma
print(int(dp[k]))
``` | output | 1 | 62,936 | 9 | 125,873 |
Provide a correct Python 3 solution for this coding contest problem.
There are N children, numbered 1, 2, \ldots, N.
They have decided to share K candies among themselves. Here, for each i (1 \leq i \leq N), Child i must receive between 0 and a_i candies (inclusive). Also, no candies should be left over.
Find the number of ways for them to share candies, modulo 10^9 + 7. Here, two ways are said to be different when there exists a child who receives a different number of candies.
Constraints
* All values in input are integers.
* 1 \leq N \leq 100
* 0 \leq K \leq 10^5
* 0 \leq a_i \leq K
Input
Input is given from Standard Input in the following format:
N K
a_1 a_2 \ldots a_N
Output
Print the number of ways for the children to share candies, modulo 10^9 + 7.
Examples
Input
3 4
1 2 3
Output
5
Input
1 10
9
Output
0
Input
2 0
0 0
Output
1
Input
4 100000
100000 100000 100000 100000
Output
665683269 | instruction | 0 | 62,937 | 9 | 125,874 |
"Correct Solution:
```
n, k = map(int, input().split())
a = list(map(int, input().split()))
mod = 10**9 + 7
dp = [[0] * (k+1) for _ in range(n)]
for j in range(a[0] + 1):
dp[0][j] = 1
for i in range(1, n):
for j in range(k + 1):
if j == 0:
dp[i][j] = 1
else:
dp[i][j] = dp[i-1][j] + dp[i][j-1]
if j >= a[i] + 1:
dp[i][j] -= dp[i-1][j-a[i]-1]
dp[i][j] = dp[i][j] % mod
print(dp[-1][-1])
``` | output | 1 | 62,937 | 9 | 125,875 |
Provide a correct Python 3 solution for this coding contest problem.
There are N children, numbered 1, 2, \ldots, N.
They have decided to share K candies among themselves. Here, for each i (1 \leq i \leq N), Child i must receive between 0 and a_i candies (inclusive). Also, no candies should be left over.
Find the number of ways for them to share candies, modulo 10^9 + 7. Here, two ways are said to be different when there exists a child who receives a different number of candies.
Constraints
* All values in input are integers.
* 1 \leq N \leq 100
* 0 \leq K \leq 10^5
* 0 \leq a_i \leq K
Input
Input is given from Standard Input in the following format:
N K
a_1 a_2 \ldots a_N
Output
Print the number of ways for the children to share candies, modulo 10^9 + 7.
Examples
Input
3 4
1 2 3
Output
5
Input
1 10
9
Output
0
Input
2 0
0 0
Output
1
Input
4 100000
100000 100000 100000 100000
Output
665683269 | instruction | 0 | 62,938 | 9 | 125,876 |
"Correct Solution:
```
from itertools import accumulate
def solve():
MOD = 10**9 + 7
N, K = map(int, input().split())
As = list(map(int, input().split()))
dp = [0] * (K+1)
dp[0] = 1
for A in As:
dp = list(accumulate(dp))
for j, d in enumerate(dp[:K-A], start=A+1):
dp[j] -= d
dp = [dpi % MOD for dpi in dp]
print(dp[K])
solve()
``` | output | 1 | 62,938 | 9 | 125,877 |
Provide a correct Python 3 solution for this coding contest problem.
There are N children, numbered 1, 2, \ldots, N.
They have decided to share K candies among themselves. Here, for each i (1 \leq i \leq N), Child i must receive between 0 and a_i candies (inclusive). Also, no candies should be left over.
Find the number of ways for them to share candies, modulo 10^9 + 7. Here, two ways are said to be different when there exists a child who receives a different number of candies.
Constraints
* All values in input are integers.
* 1 \leq N \leq 100
* 0 \leq K \leq 10^5
* 0 \leq a_i \leq K
Input
Input is given from Standard Input in the following format:
N K
a_1 a_2 \ldots a_N
Output
Print the number of ways for the children to share candies, modulo 10^9 + 7.
Examples
Input
3 4
1 2 3
Output
5
Input
1 10
9
Output
0
Input
2 0
0 0
Output
1
Input
4 100000
100000 100000 100000 100000
Output
665683269 | instruction | 0 | 62,939 | 9 | 125,878 |
"Correct Solution:
```
large_p = 10**9 + 7
from itertools import accumulate
from itertools import chain
def main():
n, k = map(int, input().split())
a = tuple(map(int, input().split()))
dp = [[0] * (k+1) for _ in range(n+1)]
dp[0][0] = 1
for i1 in range(n):
accum = tuple(chain([0], accumulate(dp[i1])))
for i2 in range(k + 1):
t = max(0, i2 - a[i1])
dp[i1 + 1][i2] += accum[i2+1] - accum[t] + large_p
dp[i1 + 1][i2] %= large_p
print(dp[n][k])
if __name__ == '__main__':
main()
``` | output | 1 | 62,939 | 9 | 125,879 |
Provide a correct Python 3 solution for this coding contest problem.
There are N children, numbered 1, 2, \ldots, N.
They have decided to share K candies among themselves. Here, for each i (1 \leq i \leq N), Child i must receive between 0 and a_i candies (inclusive). Also, no candies should be left over.
Find the number of ways for them to share candies, modulo 10^9 + 7. Here, two ways are said to be different when there exists a child who receives a different number of candies.
Constraints
* All values in input are integers.
* 1 \leq N \leq 100
* 0 \leq K \leq 10^5
* 0 \leq a_i \leq K
Input
Input is given from Standard Input in the following format:
N K
a_1 a_2 \ldots a_N
Output
Print the number of ways for the children to share candies, modulo 10^9 + 7.
Examples
Input
3 4
1 2 3
Output
5
Input
1 10
9
Output
0
Input
2 0
0 0
Output
1
Input
4 100000
100000 100000 100000 100000
Output
665683269 | instruction | 0 | 62,940 | 9 | 125,880 |
"Correct Solution:
```
# coding: utf-8
# Your code here!
MOD=10**9+7
n,k = [int(i) for i in input().split()]
aa = [int(i) for i in input().split()]
dp=[0]*(2*k+1)
dp[0]=1
for a in aa:
l=k-a
s=sum(dp[l:k+1])%MOD
for i in range(k,-1,-1):
# print(s,i,l)
s-=dp[i]
s%=MOD
dp[i] += s
l-=1
s+=dp[l]
# print(dp)
print(dp[k]%MOD)
``` | output | 1 | 62,940 | 9 | 125,881 |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.