message stringlengths 2 39.6k | message_type stringclasses 2 values | message_id int64 0 1 | conversation_id int64 219 108k | cluster float64 11 11 | __index_level_0__ int64 438 217k |
|---|---|---|---|---|---|
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
Write a program which reads a list of student test scores and evaluates the performance for each student.
The test scores for a student include scores of the midterm examination m (out of 50), the final examination f (out of 50) and the makeup examination r (out of 100). If the student does not take the examination, the score is indicated by -1.
The final performance of a student is evaluated by the following procedure:
* If the student does not take the midterm or final examination, the student's grade shall be F.
* If the total score of the midterm and final examination is greater than or equal to 80, the student's grade shall be A.
* If the total score of the midterm and final examination is greater than or equal to 65 and less than 80, the student's grade shall be B.
* If the total score of the midterm and final examination is greater than or equal to 50 and less than 65, the student's grade shall be C.
* If the total score of the midterm and final examination is greater than or equal to 30 and less than 50, the student's grade shall be D. However, if the score of the makeup examination is greater than or equal to 50, the grade shall be C.
* If the total score of the midterm and final examination is less than 30, the student's grade shall be F.
Input
The input consists of multiple datasets. For each dataset, three integers m, f and r are given in a line.
The input ends with three -1 for m, f and r respectively. Your program should not process for the terminal symbols.
The number of datasets (the number of students) does not exceed 50.
Output
For each dataset, print the grade (A, B, C, D or F) in a line.
Example
Input
40 42 -1
20 30 -1
0 2 -1
-1 -1 -1
Output
A
C
F
Submitted Solution:
```
while True:
m, f, r = map(int, input().split())
if m == -1 and f == -1 and r == -1:
break
s = sum(filter(lambda x: x != -1, [m, f]))
if s >= 80:
print('A')
elif s >= 65:
print('B')
elif s >= 50:
print('C')
elif s >= 30:
if r >= 50:
print('C')
else:
print('D')
else:
print('F')
``` | instruction | 0 | 38,600 | 11 | 77,200 |
No | output | 1 | 38,600 | 11 | 77,201 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
Write a program which reads a list of student test scores and evaluates the performance for each student.
The test scores for a student include scores of the midterm examination m (out of 50), the final examination f (out of 50) and the makeup examination r (out of 100). If the student does not take the examination, the score is indicated by -1.
The final performance of a student is evaluated by the following procedure:
* If the student does not take the midterm or final examination, the student's grade shall be F.
* If the total score of the midterm and final examination is greater than or equal to 80, the student's grade shall be A.
* If the total score of the midterm and final examination is greater than or equal to 65 and less than 80, the student's grade shall be B.
* If the total score of the midterm and final examination is greater than or equal to 50 and less than 65, the student's grade shall be C.
* If the total score of the midterm and final examination is greater than or equal to 30 and less than 50, the student's grade shall be D. However, if the score of the makeup examination is greater than or equal to 50, the grade shall be C.
* If the total score of the midterm and final examination is less than 30, the student's grade shall be F.
Input
The input consists of multiple datasets. For each dataset, three integers m, f and r are given in a line.
The input ends with three -1 for m, f and r respectively. Your program should not process for the terminal symbols.
The number of datasets (the number of students) does not exceed 50.
Output
For each dataset, print the grade (A, B, C, D or F) in a line.
Example
Input
40 42 -1
20 30 -1
0 2 -1
-1 -1 -1
Output
A
C
F
Submitted Solution:
```
while True:
(m, f, r) = map(int, raw_input().split())
if m == f == r == -1:
break
elif (m == -1 or f == -1) or (m + f < 30):
print "F"
elif m + f >= 80:
print "A"
elif 65 <= m + f < 80:
print "B"
elif 50 <= m + f < 65:
print "C"
elif 30 <= m + f < 50:
if r >= 50:
print "C"
else:
print "D"
``` | instruction | 0 | 38,601 | 11 | 77,202 |
No | output | 1 | 38,601 | 11 | 77,203 |
Provide tags and a correct Python 3 solution for this coding contest problem.
Limak and Radewoosh are going to compete against each other in the upcoming algorithmic contest. They are equally skilled but they won't solve problems in the same order.
There will be n problems. The i-th problem has initial score pi and it takes exactly ti minutes to solve it. Problems are sorted by difficulty — it's guaranteed that pi < pi + 1 and ti < ti + 1.
A constant c is given too, representing the speed of loosing points. Then, submitting the i-th problem at time x (x minutes after the start of the contest) gives max(0, pi - c·x) points.
Limak is going to solve problems in order 1, 2, ..., n (sorted increasingly by pi). Radewoosh is going to solve them in order n, n - 1, ..., 1 (sorted decreasingly by pi). Your task is to predict the outcome — print the name of the winner (person who gets more points at the end) or a word "Tie" in case of a tie.
You may assume that the duration of the competition is greater or equal than the sum of all ti. That means both Limak and Radewoosh will accept all n problems.
Input
The first line contains two integers n and c (1 ≤ n ≤ 50, 1 ≤ c ≤ 1000) — the number of problems and the constant representing the speed of loosing points.
The second line contains n integers p1, p2, ..., pn (1 ≤ pi ≤ 1000, pi < pi + 1) — initial scores.
The third line contains n integers t1, t2, ..., tn (1 ≤ ti ≤ 1000, ti < ti + 1) where ti denotes the number of minutes one needs to solve the i-th problem.
Output
Print "Limak" (without quotes) if Limak will get more points in total. Print "Radewoosh" (without quotes) if Radewoosh will get more points in total. Print "Tie" (without quotes) if Limak and Radewoosh will get the same total number of points.
Examples
Input
3 2
50 85 250
10 15 25
Output
Limak
Input
3 6
50 85 250
10 15 25
Output
Radewoosh
Input
8 1
10 20 30 40 50 60 70 80
8 10 58 63 71 72 75 76
Output
Tie
Note
In the first sample, there are 3 problems. Limak solves them as follows:
1. Limak spends 10 minutes on the 1-st problem and he gets 50 - c·10 = 50 - 2·10 = 30 points.
2. Limak spends 15 minutes on the 2-nd problem so he submits it 10 + 15 = 25 minutes after the start of the contest. For the 2-nd problem he gets 85 - 2·25 = 35 points.
3. He spends 25 minutes on the 3-rd problem so he submits it 10 + 15 + 25 = 50 minutes after the start. For this problem he gets 250 - 2·50 = 150 points.
So, Limak got 30 + 35 + 150 = 215 points.
Radewoosh solves problem in the reversed order:
1. Radewoosh solves 3-rd problem after 25 minutes so he gets 250 - 2·25 = 200 points.
2. He spends 15 minutes on the 2-nd problem so he submits it 25 + 15 = 40 minutes after the start. He gets 85 - 2·40 = 5 points for this problem.
3. He spends 10 minutes on the 1-st problem so he submits it 25 + 15 + 10 = 50 minutes after the start. He gets max(0, 50 - 2·50) = max(0, - 50) = 0 points.
Radewoosh got 200 + 5 + 0 = 205 points in total. Limak has 215 points so Limak wins.
In the second sample, Limak will get 0 points for each problem and Radewoosh will first solve the hardest problem and he will get 250 - 6·25 = 100 points for that. Radewoosh will get 0 points for other two problems but he is the winner anyway.
In the third sample, Limak will get 2 points for the 1-st problem and 2 points for the 2-nd problem. Radewoosh will get 4 points for the 8-th problem. They won't get points for other problems and thus there is a tie because 2 + 2 = 4. | instruction | 0 | 39,135 | 11 | 78,270 |
Tags: implementation
Correct Solution:
```
[n, c] = map(int, input().split())
p = list(map(int, input().split()))
t = list(map(int, input().split()))
a = 0
b = 0
A = []
B = []
for i in range(n):
A.append(t[i])
B.append(t[n-i-1])
a = a + max(0,p[i] - c * sum(A))
b = b + max(0,p[n-i-1] - c * sum(B))
if a > b : print('Limak')
if a < b : print('Radewoosh')
if a == b : print('Tie')
``` | output | 1 | 39,135 | 11 | 78,271 |
Provide tags and a correct Python 3 solution for this coding contest problem.
Limak and Radewoosh are going to compete against each other in the upcoming algorithmic contest. They are equally skilled but they won't solve problems in the same order.
There will be n problems. The i-th problem has initial score pi and it takes exactly ti minutes to solve it. Problems are sorted by difficulty — it's guaranteed that pi < pi + 1 and ti < ti + 1.
A constant c is given too, representing the speed of loosing points. Then, submitting the i-th problem at time x (x minutes after the start of the contest) gives max(0, pi - c·x) points.
Limak is going to solve problems in order 1, 2, ..., n (sorted increasingly by pi). Radewoosh is going to solve them in order n, n - 1, ..., 1 (sorted decreasingly by pi). Your task is to predict the outcome — print the name of the winner (person who gets more points at the end) or a word "Tie" in case of a tie.
You may assume that the duration of the competition is greater or equal than the sum of all ti. That means both Limak and Radewoosh will accept all n problems.
Input
The first line contains two integers n and c (1 ≤ n ≤ 50, 1 ≤ c ≤ 1000) — the number of problems and the constant representing the speed of loosing points.
The second line contains n integers p1, p2, ..., pn (1 ≤ pi ≤ 1000, pi < pi + 1) — initial scores.
The third line contains n integers t1, t2, ..., tn (1 ≤ ti ≤ 1000, ti < ti + 1) where ti denotes the number of minutes one needs to solve the i-th problem.
Output
Print "Limak" (without quotes) if Limak will get more points in total. Print "Radewoosh" (without quotes) if Radewoosh will get more points in total. Print "Tie" (without quotes) if Limak and Radewoosh will get the same total number of points.
Examples
Input
3 2
50 85 250
10 15 25
Output
Limak
Input
3 6
50 85 250
10 15 25
Output
Radewoosh
Input
8 1
10 20 30 40 50 60 70 80
8 10 58 63 71 72 75 76
Output
Tie
Note
In the first sample, there are 3 problems. Limak solves them as follows:
1. Limak spends 10 minutes on the 1-st problem and he gets 50 - c·10 = 50 - 2·10 = 30 points.
2. Limak spends 15 minutes on the 2-nd problem so he submits it 10 + 15 = 25 minutes after the start of the contest. For the 2-nd problem he gets 85 - 2·25 = 35 points.
3. He spends 25 minutes on the 3-rd problem so he submits it 10 + 15 + 25 = 50 minutes after the start. For this problem he gets 250 - 2·50 = 150 points.
So, Limak got 30 + 35 + 150 = 215 points.
Radewoosh solves problem in the reversed order:
1. Radewoosh solves 3-rd problem after 25 minutes so he gets 250 - 2·25 = 200 points.
2. He spends 15 minutes on the 2-nd problem so he submits it 25 + 15 = 40 minutes after the start. He gets 85 - 2·40 = 5 points for this problem.
3. He spends 10 minutes on the 1-st problem so he submits it 25 + 15 + 10 = 50 minutes after the start. He gets max(0, 50 - 2·50) = max(0, - 50) = 0 points.
Radewoosh got 200 + 5 + 0 = 205 points in total. Limak has 215 points so Limak wins.
In the second sample, Limak will get 0 points for each problem and Radewoosh will first solve the hardest problem and he will get 250 - 6·25 = 100 points for that. Radewoosh will get 0 points for other two problems but he is the winner anyway.
In the third sample, Limak will get 2 points for the 1-st problem and 2 points for the 2-nd problem. Radewoosh will get 4 points for the 8-th problem. They won't get points for other problems and thus there is a tie because 2 + 2 = 4. | instruction | 0 | 39,136 | 11 | 78,272 |
Tags: implementation
Correct Solution:
```
n,c=[int(x) for x in input().split()]
l=[int(x) for x in input().split()]
r=[int(x) for x in input().split()]
x,y=0,0
for i in range(len(r)):
x+=max(0,(l[i]-sum(r[0:i+1])*c))
y+=max(0,(l[len(r)-1-i]-sum(r[-1:-(i+2):-1])*c))
if x>y:
print("Limak")
elif x<y:
print("Radewoosh")
else:
print("Tie")
``` | output | 1 | 39,136 | 11 | 78,273 |
Provide tags and a correct Python 3 solution for this coding contest problem.
Limak and Radewoosh are going to compete against each other in the upcoming algorithmic contest. They are equally skilled but they won't solve problems in the same order.
There will be n problems. The i-th problem has initial score pi and it takes exactly ti minutes to solve it. Problems are sorted by difficulty — it's guaranteed that pi < pi + 1 and ti < ti + 1.
A constant c is given too, representing the speed of loosing points. Then, submitting the i-th problem at time x (x minutes after the start of the contest) gives max(0, pi - c·x) points.
Limak is going to solve problems in order 1, 2, ..., n (sorted increasingly by pi). Radewoosh is going to solve them in order n, n - 1, ..., 1 (sorted decreasingly by pi). Your task is to predict the outcome — print the name of the winner (person who gets more points at the end) or a word "Tie" in case of a tie.
You may assume that the duration of the competition is greater or equal than the sum of all ti. That means both Limak and Radewoosh will accept all n problems.
Input
The first line contains two integers n and c (1 ≤ n ≤ 50, 1 ≤ c ≤ 1000) — the number of problems and the constant representing the speed of loosing points.
The second line contains n integers p1, p2, ..., pn (1 ≤ pi ≤ 1000, pi < pi + 1) — initial scores.
The third line contains n integers t1, t2, ..., tn (1 ≤ ti ≤ 1000, ti < ti + 1) where ti denotes the number of minutes one needs to solve the i-th problem.
Output
Print "Limak" (without quotes) if Limak will get more points in total. Print "Radewoosh" (without quotes) if Radewoosh will get more points in total. Print "Tie" (without quotes) if Limak and Radewoosh will get the same total number of points.
Examples
Input
3 2
50 85 250
10 15 25
Output
Limak
Input
3 6
50 85 250
10 15 25
Output
Radewoosh
Input
8 1
10 20 30 40 50 60 70 80
8 10 58 63 71 72 75 76
Output
Tie
Note
In the first sample, there are 3 problems. Limak solves them as follows:
1. Limak spends 10 minutes on the 1-st problem and he gets 50 - c·10 = 50 - 2·10 = 30 points.
2. Limak spends 15 minutes on the 2-nd problem so he submits it 10 + 15 = 25 minutes after the start of the contest. For the 2-nd problem he gets 85 - 2·25 = 35 points.
3. He spends 25 minutes on the 3-rd problem so he submits it 10 + 15 + 25 = 50 minutes after the start. For this problem he gets 250 - 2·50 = 150 points.
So, Limak got 30 + 35 + 150 = 215 points.
Radewoosh solves problem in the reversed order:
1. Radewoosh solves 3-rd problem after 25 minutes so he gets 250 - 2·25 = 200 points.
2. He spends 15 minutes on the 2-nd problem so he submits it 25 + 15 = 40 minutes after the start. He gets 85 - 2·40 = 5 points for this problem.
3. He spends 10 minutes on the 1-st problem so he submits it 25 + 15 + 10 = 50 minutes after the start. He gets max(0, 50 - 2·50) = max(0, - 50) = 0 points.
Radewoosh got 200 + 5 + 0 = 205 points in total. Limak has 215 points so Limak wins.
In the second sample, Limak will get 0 points for each problem and Radewoosh will first solve the hardest problem and he will get 250 - 6·25 = 100 points for that. Radewoosh will get 0 points for other two problems but he is the winner anyway.
In the third sample, Limak will get 2 points for the 1-st problem and 2 points for the 2-nd problem. Radewoosh will get 4 points for the 8-th problem. They won't get points for other problems and thus there is a tie because 2 + 2 = 4. | instruction | 0 | 39,137 | 11 | 78,274 |
Tags: implementation
Correct Solution:
```
n, c = [int(i) for i in input().split()]
p = [int(i) for i in input().split()]
t = [int(i) for i in input().split()]
ti, p1 = 0, 0
for i in range(n):
ti += t[i]
p1 += max(0, p[i] - c * ti)
ti, p2 = 0, 0
for i in range(n - 1, -1, -1):
ti += t[i]
p2 += max(0, p[i] - c * ti)
if p1 > p2:
print('Limak')
elif p2 > p1:
print('Radewoosh')
else:
print('Tie')
``` | output | 1 | 39,137 | 11 | 78,275 |
Provide tags and a correct Python 3 solution for this coding contest problem.
Limak and Radewoosh are going to compete against each other in the upcoming algorithmic contest. They are equally skilled but they won't solve problems in the same order.
There will be n problems. The i-th problem has initial score pi and it takes exactly ti minutes to solve it. Problems are sorted by difficulty — it's guaranteed that pi < pi + 1 and ti < ti + 1.
A constant c is given too, representing the speed of loosing points. Then, submitting the i-th problem at time x (x minutes after the start of the contest) gives max(0, pi - c·x) points.
Limak is going to solve problems in order 1, 2, ..., n (sorted increasingly by pi). Radewoosh is going to solve them in order n, n - 1, ..., 1 (sorted decreasingly by pi). Your task is to predict the outcome — print the name of the winner (person who gets more points at the end) or a word "Tie" in case of a tie.
You may assume that the duration of the competition is greater or equal than the sum of all ti. That means both Limak and Radewoosh will accept all n problems.
Input
The first line contains two integers n and c (1 ≤ n ≤ 50, 1 ≤ c ≤ 1000) — the number of problems and the constant representing the speed of loosing points.
The second line contains n integers p1, p2, ..., pn (1 ≤ pi ≤ 1000, pi < pi + 1) — initial scores.
The third line contains n integers t1, t2, ..., tn (1 ≤ ti ≤ 1000, ti < ti + 1) where ti denotes the number of minutes one needs to solve the i-th problem.
Output
Print "Limak" (without quotes) if Limak will get more points in total. Print "Radewoosh" (without quotes) if Radewoosh will get more points in total. Print "Tie" (without quotes) if Limak and Radewoosh will get the same total number of points.
Examples
Input
3 2
50 85 250
10 15 25
Output
Limak
Input
3 6
50 85 250
10 15 25
Output
Radewoosh
Input
8 1
10 20 30 40 50 60 70 80
8 10 58 63 71 72 75 76
Output
Tie
Note
In the first sample, there are 3 problems. Limak solves them as follows:
1. Limak spends 10 minutes on the 1-st problem and he gets 50 - c·10 = 50 - 2·10 = 30 points.
2. Limak spends 15 minutes on the 2-nd problem so he submits it 10 + 15 = 25 minutes after the start of the contest. For the 2-nd problem he gets 85 - 2·25 = 35 points.
3. He spends 25 minutes on the 3-rd problem so he submits it 10 + 15 + 25 = 50 minutes after the start. For this problem he gets 250 - 2·50 = 150 points.
So, Limak got 30 + 35 + 150 = 215 points.
Radewoosh solves problem in the reversed order:
1. Radewoosh solves 3-rd problem after 25 minutes so he gets 250 - 2·25 = 200 points.
2. He spends 15 minutes on the 2-nd problem so he submits it 25 + 15 = 40 minutes after the start. He gets 85 - 2·40 = 5 points for this problem.
3. He spends 10 minutes on the 1-st problem so he submits it 25 + 15 + 10 = 50 minutes after the start. He gets max(0, 50 - 2·50) = max(0, - 50) = 0 points.
Radewoosh got 200 + 5 + 0 = 205 points in total. Limak has 215 points so Limak wins.
In the second sample, Limak will get 0 points for each problem and Radewoosh will first solve the hardest problem and he will get 250 - 6·25 = 100 points for that. Radewoosh will get 0 points for other two problems but he is the winner anyway.
In the third sample, Limak will get 2 points for the 1-st problem and 2 points for the 2-nd problem. Radewoosh will get 4 points for the 8-th problem. They won't get points for other problems and thus there is a tie because 2 + 2 = 4. | instruction | 0 | 39,138 | 11 | 78,276 |
Tags: implementation
Correct Solution:
```
n,c = map(int,input().split())
point = [*map(int,input().split())]
time= [*map(int,input().split())]
count1,count2 = 0,0
limak,rade =0,0
for i in range(n):
count1 += time[i]
limak += max(point[i]-c*count1,0)
count2 += time[n-i-1]
rade += max(point[n-i-1]-c*count2,0)
if limak>rade:
print('Limak')
elif rade>limak:
print('Radewoosh')
else:
print('Tie')
``` | output | 1 | 39,138 | 11 | 78,277 |
Provide tags and a correct Python 3 solution for this coding contest problem.
Limak and Radewoosh are going to compete against each other in the upcoming algorithmic contest. They are equally skilled but they won't solve problems in the same order.
There will be n problems. The i-th problem has initial score pi and it takes exactly ti minutes to solve it. Problems are sorted by difficulty — it's guaranteed that pi < pi + 1 and ti < ti + 1.
A constant c is given too, representing the speed of loosing points. Then, submitting the i-th problem at time x (x minutes after the start of the contest) gives max(0, pi - c·x) points.
Limak is going to solve problems in order 1, 2, ..., n (sorted increasingly by pi). Radewoosh is going to solve them in order n, n - 1, ..., 1 (sorted decreasingly by pi). Your task is to predict the outcome — print the name of the winner (person who gets more points at the end) or a word "Tie" in case of a tie.
You may assume that the duration of the competition is greater or equal than the sum of all ti. That means both Limak and Radewoosh will accept all n problems.
Input
The first line contains two integers n and c (1 ≤ n ≤ 50, 1 ≤ c ≤ 1000) — the number of problems and the constant representing the speed of loosing points.
The second line contains n integers p1, p2, ..., pn (1 ≤ pi ≤ 1000, pi < pi + 1) — initial scores.
The third line contains n integers t1, t2, ..., tn (1 ≤ ti ≤ 1000, ti < ti + 1) where ti denotes the number of minutes one needs to solve the i-th problem.
Output
Print "Limak" (without quotes) if Limak will get more points in total. Print "Radewoosh" (without quotes) if Radewoosh will get more points in total. Print "Tie" (without quotes) if Limak and Radewoosh will get the same total number of points.
Examples
Input
3 2
50 85 250
10 15 25
Output
Limak
Input
3 6
50 85 250
10 15 25
Output
Radewoosh
Input
8 1
10 20 30 40 50 60 70 80
8 10 58 63 71 72 75 76
Output
Tie
Note
In the first sample, there are 3 problems. Limak solves them as follows:
1. Limak spends 10 minutes on the 1-st problem and he gets 50 - c·10 = 50 - 2·10 = 30 points.
2. Limak spends 15 minutes on the 2-nd problem so he submits it 10 + 15 = 25 minutes after the start of the contest. For the 2-nd problem he gets 85 - 2·25 = 35 points.
3. He spends 25 minutes on the 3-rd problem so he submits it 10 + 15 + 25 = 50 minutes after the start. For this problem he gets 250 - 2·50 = 150 points.
So, Limak got 30 + 35 + 150 = 215 points.
Radewoosh solves problem in the reversed order:
1. Radewoosh solves 3-rd problem after 25 minutes so he gets 250 - 2·25 = 200 points.
2. He spends 15 minutes on the 2-nd problem so he submits it 25 + 15 = 40 minutes after the start. He gets 85 - 2·40 = 5 points for this problem.
3. He spends 10 minutes on the 1-st problem so he submits it 25 + 15 + 10 = 50 minutes after the start. He gets max(0, 50 - 2·50) = max(0, - 50) = 0 points.
Radewoosh got 200 + 5 + 0 = 205 points in total. Limak has 215 points so Limak wins.
In the second sample, Limak will get 0 points for each problem and Radewoosh will first solve the hardest problem and he will get 250 - 6·25 = 100 points for that. Radewoosh will get 0 points for other two problems but he is the winner anyway.
In the third sample, Limak will get 2 points for the 1-st problem and 2 points for the 2-nd problem. Radewoosh will get 4 points for the 8-th problem. They won't get points for other problems and thus there is a tie because 2 + 2 = 4. | instruction | 0 | 39,139 | 11 | 78,278 |
Tags: implementation
Correct Solution:
```
n,c=map(int,input().split())
l=list(map(int,input().split()))
t=list(map(int,input().split()))
li=0
rd=0
tu=0
t1=0
for i in range(len(l)):
tu=tu+t[i]
k=l[i]-c*tu
li=li+max(0,k)
for i in reversed(range(len(l))):
t1=t1+t[i]
tk=l[i]-c*t1
rd=rd+max(0,tk)
if(li>rd):
print("Limak")
elif(rd>li):
print("Radewoosh")
else:
print("Tie")
``` | output | 1 | 39,139 | 11 | 78,279 |
Provide tags and a correct Python 3 solution for this coding contest problem.
Limak and Radewoosh are going to compete against each other in the upcoming algorithmic contest. They are equally skilled but they won't solve problems in the same order.
There will be n problems. The i-th problem has initial score pi and it takes exactly ti minutes to solve it. Problems are sorted by difficulty — it's guaranteed that pi < pi + 1 and ti < ti + 1.
A constant c is given too, representing the speed of loosing points. Then, submitting the i-th problem at time x (x minutes after the start of the contest) gives max(0, pi - c·x) points.
Limak is going to solve problems in order 1, 2, ..., n (sorted increasingly by pi). Radewoosh is going to solve them in order n, n - 1, ..., 1 (sorted decreasingly by pi). Your task is to predict the outcome — print the name of the winner (person who gets more points at the end) or a word "Tie" in case of a tie.
You may assume that the duration of the competition is greater or equal than the sum of all ti. That means both Limak and Radewoosh will accept all n problems.
Input
The first line contains two integers n and c (1 ≤ n ≤ 50, 1 ≤ c ≤ 1000) — the number of problems and the constant representing the speed of loosing points.
The second line contains n integers p1, p2, ..., pn (1 ≤ pi ≤ 1000, pi < pi + 1) — initial scores.
The third line contains n integers t1, t2, ..., tn (1 ≤ ti ≤ 1000, ti < ti + 1) where ti denotes the number of minutes one needs to solve the i-th problem.
Output
Print "Limak" (without quotes) if Limak will get more points in total. Print "Radewoosh" (without quotes) if Radewoosh will get more points in total. Print "Tie" (without quotes) if Limak and Radewoosh will get the same total number of points.
Examples
Input
3 2
50 85 250
10 15 25
Output
Limak
Input
3 6
50 85 250
10 15 25
Output
Radewoosh
Input
8 1
10 20 30 40 50 60 70 80
8 10 58 63 71 72 75 76
Output
Tie
Note
In the first sample, there are 3 problems. Limak solves them as follows:
1. Limak spends 10 minutes on the 1-st problem and he gets 50 - c·10 = 50 - 2·10 = 30 points.
2. Limak spends 15 minutes on the 2-nd problem so he submits it 10 + 15 = 25 minutes after the start of the contest. For the 2-nd problem he gets 85 - 2·25 = 35 points.
3. He spends 25 minutes on the 3-rd problem so he submits it 10 + 15 + 25 = 50 minutes after the start. For this problem he gets 250 - 2·50 = 150 points.
So, Limak got 30 + 35 + 150 = 215 points.
Radewoosh solves problem in the reversed order:
1. Radewoosh solves 3-rd problem after 25 minutes so he gets 250 - 2·25 = 200 points.
2. He spends 15 minutes on the 2-nd problem so he submits it 25 + 15 = 40 minutes after the start. He gets 85 - 2·40 = 5 points for this problem.
3. He spends 10 minutes on the 1-st problem so he submits it 25 + 15 + 10 = 50 minutes after the start. He gets max(0, 50 - 2·50) = max(0, - 50) = 0 points.
Radewoosh got 200 + 5 + 0 = 205 points in total. Limak has 215 points so Limak wins.
In the second sample, Limak will get 0 points for each problem and Radewoosh will first solve the hardest problem and he will get 250 - 6·25 = 100 points for that. Radewoosh will get 0 points for other two problems but he is the winner anyway.
In the third sample, Limak will get 2 points for the 1-st problem and 2 points for the 2-nd problem. Radewoosh will get 4 points for the 8-th problem. They won't get points for other problems and thus there is a tie because 2 + 2 = 4. | instruction | 0 | 39,140 | 11 | 78,280 |
Tags: implementation
Correct Solution:
```
n, c = [int(tmp) for tmp in input().split()]
p = [int(tmp) for tmp in input().split()]
t = [int(tmp) for tmp in input().split()]
limak = 0
radewoosh = 0
timel = 0
timer = 0
for i in range(n) :
cekl = 0
cekr = 0
timel += t[i]
timer += t[n-i-1]
cekl = max(cekl, p[i] - (timel*c))
cekr = max(cekr, p[n-i-1]-(timer*c))
limak += cekl
radewoosh += cekr
if limak > radewoosh :
print("Limak")
elif limak < radewoosh :
print("Radewoosh")
elif limak == radewoosh :
print("Tie")
``` | output | 1 | 39,140 | 11 | 78,281 |
Provide tags and a correct Python 3 solution for this coding contest problem.
Limak and Radewoosh are going to compete against each other in the upcoming algorithmic contest. They are equally skilled but they won't solve problems in the same order.
There will be n problems. The i-th problem has initial score pi and it takes exactly ti minutes to solve it. Problems are sorted by difficulty — it's guaranteed that pi < pi + 1 and ti < ti + 1.
A constant c is given too, representing the speed of loosing points. Then, submitting the i-th problem at time x (x minutes after the start of the contest) gives max(0, pi - c·x) points.
Limak is going to solve problems in order 1, 2, ..., n (sorted increasingly by pi). Radewoosh is going to solve them in order n, n - 1, ..., 1 (sorted decreasingly by pi). Your task is to predict the outcome — print the name of the winner (person who gets more points at the end) or a word "Tie" in case of a tie.
You may assume that the duration of the competition is greater or equal than the sum of all ti. That means both Limak and Radewoosh will accept all n problems.
Input
The first line contains two integers n and c (1 ≤ n ≤ 50, 1 ≤ c ≤ 1000) — the number of problems and the constant representing the speed of loosing points.
The second line contains n integers p1, p2, ..., pn (1 ≤ pi ≤ 1000, pi < pi + 1) — initial scores.
The third line contains n integers t1, t2, ..., tn (1 ≤ ti ≤ 1000, ti < ti + 1) where ti denotes the number of minutes one needs to solve the i-th problem.
Output
Print "Limak" (without quotes) if Limak will get more points in total. Print "Radewoosh" (without quotes) if Radewoosh will get more points in total. Print "Tie" (without quotes) if Limak and Radewoosh will get the same total number of points.
Examples
Input
3 2
50 85 250
10 15 25
Output
Limak
Input
3 6
50 85 250
10 15 25
Output
Radewoosh
Input
8 1
10 20 30 40 50 60 70 80
8 10 58 63 71 72 75 76
Output
Tie
Note
In the first sample, there are 3 problems. Limak solves them as follows:
1. Limak spends 10 minutes on the 1-st problem and he gets 50 - c·10 = 50 - 2·10 = 30 points.
2. Limak spends 15 minutes on the 2-nd problem so he submits it 10 + 15 = 25 minutes after the start of the contest. For the 2-nd problem he gets 85 - 2·25 = 35 points.
3. He spends 25 minutes on the 3-rd problem so he submits it 10 + 15 + 25 = 50 minutes after the start. For this problem he gets 250 - 2·50 = 150 points.
So, Limak got 30 + 35 + 150 = 215 points.
Radewoosh solves problem in the reversed order:
1. Radewoosh solves 3-rd problem after 25 minutes so he gets 250 - 2·25 = 200 points.
2. He spends 15 minutes on the 2-nd problem so he submits it 25 + 15 = 40 minutes after the start. He gets 85 - 2·40 = 5 points for this problem.
3. He spends 10 minutes on the 1-st problem so he submits it 25 + 15 + 10 = 50 minutes after the start. He gets max(0, 50 - 2·50) = max(0, - 50) = 0 points.
Radewoosh got 200 + 5 + 0 = 205 points in total. Limak has 215 points so Limak wins.
In the second sample, Limak will get 0 points for each problem and Radewoosh will first solve the hardest problem and he will get 250 - 6·25 = 100 points for that. Radewoosh will get 0 points for other two problems but he is the winner anyway.
In the third sample, Limak will get 2 points for the 1-st problem and 2 points for the 2-nd problem. Radewoosh will get 4 points for the 8-th problem. They won't get points for other problems and thus there is a tie because 2 + 2 = 4. | instruction | 0 | 39,141 | 11 | 78,282 |
Tags: implementation
Correct Solution:
```
n, c = list(map(int, input().split()))
p = list(map(int, input().split()))
t = list(map(int, input().split()))
l, r = 0, 0
tl = 0
for i in range(n):
l += max(0, p[i] - c*(t[i] + tl))
tl += t[i]
tr = 0
for i in range(n-1, -1, -1):
r += max(0, p[i] - c*(t[i] + tr))
tr += t[i]
if r > l:
print("Radewoosh")
elif l > r:
print("Limak")
else:
print("Tie")
``` | output | 1 | 39,141 | 11 | 78,283 |
Provide tags and a correct Python 3 solution for this coding contest problem.
Limak and Radewoosh are going to compete against each other in the upcoming algorithmic contest. They are equally skilled but they won't solve problems in the same order.
There will be n problems. The i-th problem has initial score pi and it takes exactly ti minutes to solve it. Problems are sorted by difficulty — it's guaranteed that pi < pi + 1 and ti < ti + 1.
A constant c is given too, representing the speed of loosing points. Then, submitting the i-th problem at time x (x minutes after the start of the contest) gives max(0, pi - c·x) points.
Limak is going to solve problems in order 1, 2, ..., n (sorted increasingly by pi). Radewoosh is going to solve them in order n, n - 1, ..., 1 (sorted decreasingly by pi). Your task is to predict the outcome — print the name of the winner (person who gets more points at the end) or a word "Tie" in case of a tie.
You may assume that the duration of the competition is greater or equal than the sum of all ti. That means both Limak and Radewoosh will accept all n problems.
Input
The first line contains two integers n and c (1 ≤ n ≤ 50, 1 ≤ c ≤ 1000) — the number of problems and the constant representing the speed of loosing points.
The second line contains n integers p1, p2, ..., pn (1 ≤ pi ≤ 1000, pi < pi + 1) — initial scores.
The third line contains n integers t1, t2, ..., tn (1 ≤ ti ≤ 1000, ti < ti + 1) where ti denotes the number of minutes one needs to solve the i-th problem.
Output
Print "Limak" (without quotes) if Limak will get more points in total. Print "Radewoosh" (without quotes) if Radewoosh will get more points in total. Print "Tie" (without quotes) if Limak and Radewoosh will get the same total number of points.
Examples
Input
3 2
50 85 250
10 15 25
Output
Limak
Input
3 6
50 85 250
10 15 25
Output
Radewoosh
Input
8 1
10 20 30 40 50 60 70 80
8 10 58 63 71 72 75 76
Output
Tie
Note
In the first sample, there are 3 problems. Limak solves them as follows:
1. Limak spends 10 minutes on the 1-st problem and he gets 50 - c·10 = 50 - 2·10 = 30 points.
2. Limak spends 15 minutes on the 2-nd problem so he submits it 10 + 15 = 25 minutes after the start of the contest. For the 2-nd problem he gets 85 - 2·25 = 35 points.
3. He spends 25 minutes on the 3-rd problem so he submits it 10 + 15 + 25 = 50 minutes after the start. For this problem he gets 250 - 2·50 = 150 points.
So, Limak got 30 + 35 + 150 = 215 points.
Radewoosh solves problem in the reversed order:
1. Radewoosh solves 3-rd problem after 25 minutes so he gets 250 - 2·25 = 200 points.
2. He spends 15 minutes on the 2-nd problem so he submits it 25 + 15 = 40 minutes after the start. He gets 85 - 2·40 = 5 points for this problem.
3. He spends 10 minutes on the 1-st problem so he submits it 25 + 15 + 10 = 50 minutes after the start. He gets max(0, 50 - 2·50) = max(0, - 50) = 0 points.
Radewoosh got 200 + 5 + 0 = 205 points in total. Limak has 215 points so Limak wins.
In the second sample, Limak will get 0 points for each problem and Radewoosh will first solve the hardest problem and he will get 250 - 6·25 = 100 points for that. Radewoosh will get 0 points for other two problems but he is the winner anyway.
In the third sample, Limak will get 2 points for the 1-st problem and 2 points for the 2-nd problem. Radewoosh will get 4 points for the 8-th problem. They won't get points for other problems and thus there is a tie because 2 + 2 = 4. | instruction | 0 | 39,142 | 11 | 78,284 |
Tags: implementation
Correct Solution:
```
a,b = map(int,input().split())
n = list(map(int,input().split()))
m = list(map(int,input().split()))
l,y = [],[]
x,q,w,o= 0,0,0,0
for e in m :
x = x+e
l.append(x)
for i in range(len(l)):
q = q+max(0,n[i]-b*l[i])
n.reverse()
m.reverse()
for p in m :
w = w+p
y.append(w)
for r in range(len(y)):
o = o+ max(0,n[r]-b*y[r])
if q>o:
print("Limak")
elif q == o:
print("Tie")
else:
print("Radewoosh")
``` | output | 1 | 39,142 | 11 | 78,285 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
Limak and Radewoosh are going to compete against each other in the upcoming algorithmic contest. They are equally skilled but they won't solve problems in the same order.
There will be n problems. The i-th problem has initial score pi and it takes exactly ti minutes to solve it. Problems are sorted by difficulty — it's guaranteed that pi < pi + 1 and ti < ti + 1.
A constant c is given too, representing the speed of loosing points. Then, submitting the i-th problem at time x (x minutes after the start of the contest) gives max(0, pi - c·x) points.
Limak is going to solve problems in order 1, 2, ..., n (sorted increasingly by pi). Radewoosh is going to solve them in order n, n - 1, ..., 1 (sorted decreasingly by pi). Your task is to predict the outcome — print the name of the winner (person who gets more points at the end) or a word "Tie" in case of a tie.
You may assume that the duration of the competition is greater or equal than the sum of all ti. That means both Limak and Radewoosh will accept all n problems.
Input
The first line contains two integers n and c (1 ≤ n ≤ 50, 1 ≤ c ≤ 1000) — the number of problems and the constant representing the speed of loosing points.
The second line contains n integers p1, p2, ..., pn (1 ≤ pi ≤ 1000, pi < pi + 1) — initial scores.
The third line contains n integers t1, t2, ..., tn (1 ≤ ti ≤ 1000, ti < ti + 1) where ti denotes the number of minutes one needs to solve the i-th problem.
Output
Print "Limak" (without quotes) if Limak will get more points in total. Print "Radewoosh" (without quotes) if Radewoosh will get more points in total. Print "Tie" (without quotes) if Limak and Radewoosh will get the same total number of points.
Examples
Input
3 2
50 85 250
10 15 25
Output
Limak
Input
3 6
50 85 250
10 15 25
Output
Radewoosh
Input
8 1
10 20 30 40 50 60 70 80
8 10 58 63 71 72 75 76
Output
Tie
Note
In the first sample, there are 3 problems. Limak solves them as follows:
1. Limak spends 10 minutes on the 1-st problem and he gets 50 - c·10 = 50 - 2·10 = 30 points.
2. Limak spends 15 minutes on the 2-nd problem so he submits it 10 + 15 = 25 minutes after the start of the contest. For the 2-nd problem he gets 85 - 2·25 = 35 points.
3. He spends 25 minutes on the 3-rd problem so he submits it 10 + 15 + 25 = 50 minutes after the start. For this problem he gets 250 - 2·50 = 150 points.
So, Limak got 30 + 35 + 150 = 215 points.
Radewoosh solves problem in the reversed order:
1. Radewoosh solves 3-rd problem after 25 minutes so he gets 250 - 2·25 = 200 points.
2. He spends 15 minutes on the 2-nd problem so he submits it 25 + 15 = 40 minutes after the start. He gets 85 - 2·40 = 5 points for this problem.
3. He spends 10 minutes on the 1-st problem so he submits it 25 + 15 + 10 = 50 minutes after the start. He gets max(0, 50 - 2·50) = max(0, - 50) = 0 points.
Radewoosh got 200 + 5 + 0 = 205 points in total. Limak has 215 points so Limak wins.
In the second sample, Limak will get 0 points for each problem and Radewoosh will first solve the hardest problem and he will get 250 - 6·25 = 100 points for that. Radewoosh will get 0 points for other two problems but he is the winner anyway.
In the third sample, Limak will get 2 points for the 1-st problem and 2 points for the 2-nd problem. Radewoosh will get 4 points for the 8-th problem. They won't get points for other problems and thus there is a tie because 2 + 2 = 4.
Submitted Solution:
```
def fon(l,t,c,r):
d = 0
e=0
for i in range(r):
d+=t[i]
if l[i] - c*d > 0:
e += l[i] - c*d
else:
pass
return e
n,c = map(int,input().split())
l = [int(i) for i in input().split()]
t = [int(i) for i in input().split()]
l1 = l[::-1]
t1 = t[::-1]
a = fon(l,t,c,n)
b = fon(l1,t1,c,n)
if a>b :
print("Limak")
elif a<b:
print("Radewoosh")
else:
print("Tie")
``` | instruction | 0 | 39,143 | 11 | 78,286 |
Yes | output | 1 | 39,143 | 11 | 78,287 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
Limak and Radewoosh are going to compete against each other in the upcoming algorithmic contest. They are equally skilled but they won't solve problems in the same order.
There will be n problems. The i-th problem has initial score pi and it takes exactly ti minutes to solve it. Problems are sorted by difficulty — it's guaranteed that pi < pi + 1 and ti < ti + 1.
A constant c is given too, representing the speed of loosing points. Then, submitting the i-th problem at time x (x minutes after the start of the contest) gives max(0, pi - c·x) points.
Limak is going to solve problems in order 1, 2, ..., n (sorted increasingly by pi). Radewoosh is going to solve them in order n, n - 1, ..., 1 (sorted decreasingly by pi). Your task is to predict the outcome — print the name of the winner (person who gets more points at the end) or a word "Tie" in case of a tie.
You may assume that the duration of the competition is greater or equal than the sum of all ti. That means both Limak and Radewoosh will accept all n problems.
Input
The first line contains two integers n and c (1 ≤ n ≤ 50, 1 ≤ c ≤ 1000) — the number of problems and the constant representing the speed of loosing points.
The second line contains n integers p1, p2, ..., pn (1 ≤ pi ≤ 1000, pi < pi + 1) — initial scores.
The third line contains n integers t1, t2, ..., tn (1 ≤ ti ≤ 1000, ti < ti + 1) where ti denotes the number of minutes one needs to solve the i-th problem.
Output
Print "Limak" (without quotes) if Limak will get more points in total. Print "Radewoosh" (without quotes) if Radewoosh will get more points in total. Print "Tie" (without quotes) if Limak and Radewoosh will get the same total number of points.
Examples
Input
3 2
50 85 250
10 15 25
Output
Limak
Input
3 6
50 85 250
10 15 25
Output
Radewoosh
Input
8 1
10 20 30 40 50 60 70 80
8 10 58 63 71 72 75 76
Output
Tie
Note
In the first sample, there are 3 problems. Limak solves them as follows:
1. Limak spends 10 minutes on the 1-st problem and he gets 50 - c·10 = 50 - 2·10 = 30 points.
2. Limak spends 15 minutes on the 2-nd problem so he submits it 10 + 15 = 25 minutes after the start of the contest. For the 2-nd problem he gets 85 - 2·25 = 35 points.
3. He spends 25 minutes on the 3-rd problem so he submits it 10 + 15 + 25 = 50 minutes after the start. For this problem he gets 250 - 2·50 = 150 points.
So, Limak got 30 + 35 + 150 = 215 points.
Radewoosh solves problem in the reversed order:
1. Radewoosh solves 3-rd problem after 25 minutes so he gets 250 - 2·25 = 200 points.
2. He spends 15 minutes on the 2-nd problem so he submits it 25 + 15 = 40 minutes after the start. He gets 85 - 2·40 = 5 points for this problem.
3. He spends 10 minutes on the 1-st problem so he submits it 25 + 15 + 10 = 50 minutes after the start. He gets max(0, 50 - 2·50) = max(0, - 50) = 0 points.
Radewoosh got 200 + 5 + 0 = 205 points in total. Limak has 215 points so Limak wins.
In the second sample, Limak will get 0 points for each problem and Radewoosh will first solve the hardest problem and he will get 250 - 6·25 = 100 points for that. Radewoosh will get 0 points for other two problems but he is the winner anyway.
In the third sample, Limak will get 2 points for the 1-st problem and 2 points for the 2-nd problem. Radewoosh will get 4 points for the 8-th problem. They won't get points for other problems and thus there is a tie because 2 + 2 = 4.
Submitted Solution:
```
n, c = map(int, input().split())
p = list(map(int, input().split()))
t = list(map(int, input().split()))
s1 = s2 = 0
t1 = t2 = 0
for i in range(n):
t1 += t[i]
s1 += max(0, p[i] - c * t1)
for i in range(n - 1, -1, -1):
t2 += t[i]
s2 += max(0, p[i] - c * t2)
if s1 > s2:
print("Limak")
elif s2 > s1:
print("Radewoosh")
else:
print("Tie")
``` | instruction | 0 | 39,144 | 11 | 78,288 |
Yes | output | 1 | 39,144 | 11 | 78,289 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
Limak and Radewoosh are going to compete against each other in the upcoming algorithmic contest. They are equally skilled but they won't solve problems in the same order.
There will be n problems. The i-th problem has initial score pi and it takes exactly ti minutes to solve it. Problems are sorted by difficulty — it's guaranteed that pi < pi + 1 and ti < ti + 1.
A constant c is given too, representing the speed of loosing points. Then, submitting the i-th problem at time x (x minutes after the start of the contest) gives max(0, pi - c·x) points.
Limak is going to solve problems in order 1, 2, ..., n (sorted increasingly by pi). Radewoosh is going to solve them in order n, n - 1, ..., 1 (sorted decreasingly by pi). Your task is to predict the outcome — print the name of the winner (person who gets more points at the end) or a word "Tie" in case of a tie.
You may assume that the duration of the competition is greater or equal than the sum of all ti. That means both Limak and Radewoosh will accept all n problems.
Input
The first line contains two integers n and c (1 ≤ n ≤ 50, 1 ≤ c ≤ 1000) — the number of problems and the constant representing the speed of loosing points.
The second line contains n integers p1, p2, ..., pn (1 ≤ pi ≤ 1000, pi < pi + 1) — initial scores.
The third line contains n integers t1, t2, ..., tn (1 ≤ ti ≤ 1000, ti < ti + 1) where ti denotes the number of minutes one needs to solve the i-th problem.
Output
Print "Limak" (without quotes) if Limak will get more points in total. Print "Radewoosh" (without quotes) if Radewoosh will get more points in total. Print "Tie" (without quotes) if Limak and Radewoosh will get the same total number of points.
Examples
Input
3 2
50 85 250
10 15 25
Output
Limak
Input
3 6
50 85 250
10 15 25
Output
Radewoosh
Input
8 1
10 20 30 40 50 60 70 80
8 10 58 63 71 72 75 76
Output
Tie
Note
In the first sample, there are 3 problems. Limak solves them as follows:
1. Limak spends 10 minutes on the 1-st problem and he gets 50 - c·10 = 50 - 2·10 = 30 points.
2. Limak spends 15 minutes on the 2-nd problem so he submits it 10 + 15 = 25 minutes after the start of the contest. For the 2-nd problem he gets 85 - 2·25 = 35 points.
3. He spends 25 minutes on the 3-rd problem so he submits it 10 + 15 + 25 = 50 minutes after the start. For this problem he gets 250 - 2·50 = 150 points.
So, Limak got 30 + 35 + 150 = 215 points.
Radewoosh solves problem in the reversed order:
1. Radewoosh solves 3-rd problem after 25 minutes so he gets 250 - 2·25 = 200 points.
2. He spends 15 minutes on the 2-nd problem so he submits it 25 + 15 = 40 minutes after the start. He gets 85 - 2·40 = 5 points for this problem.
3. He spends 10 minutes on the 1-st problem so he submits it 25 + 15 + 10 = 50 minutes after the start. He gets max(0, 50 - 2·50) = max(0, - 50) = 0 points.
Radewoosh got 200 + 5 + 0 = 205 points in total. Limak has 215 points so Limak wins.
In the second sample, Limak will get 0 points for each problem and Radewoosh will first solve the hardest problem and he will get 250 - 6·25 = 100 points for that. Radewoosh will get 0 points for other two problems but he is the winner anyway.
In the third sample, Limak will get 2 points for the 1-st problem and 2 points for the 2-nd problem. Radewoosh will get 4 points for the 8-th problem. They won't get points for other problems and thus there is a tie because 2 + 2 = 4.
Submitted Solution:
```
n, c = map(int, input().split())
p = list(map(int, input().split()))
t = list(map(int, input().split()))
lim_score = 0
lim_penalty = 0
for i in range(n):
lim_penalty += t[i]
lim_score += max(0, p[i] - lim_penalty * c)
rad_score = 0
rad_penalty = 0
for i in range(n - 1, -1, -1):
rad_penalty += t[i]
rad_score += max(0, p[i] - rad_penalty * c)
if lim_score == rad_score:
print("Tie")
elif lim_score > rad_score:
print("Limak")
else:
print("Radewoosh")
``` | instruction | 0 | 39,145 | 11 | 78,290 |
Yes | output | 1 | 39,145 | 11 | 78,291 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
Limak and Radewoosh are going to compete against each other in the upcoming algorithmic contest. They are equally skilled but they won't solve problems in the same order.
There will be n problems. The i-th problem has initial score pi and it takes exactly ti minutes to solve it. Problems are sorted by difficulty — it's guaranteed that pi < pi + 1 and ti < ti + 1.
A constant c is given too, representing the speed of loosing points. Then, submitting the i-th problem at time x (x minutes after the start of the contest) gives max(0, pi - c·x) points.
Limak is going to solve problems in order 1, 2, ..., n (sorted increasingly by pi). Radewoosh is going to solve them in order n, n - 1, ..., 1 (sorted decreasingly by pi). Your task is to predict the outcome — print the name of the winner (person who gets more points at the end) or a word "Tie" in case of a tie.
You may assume that the duration of the competition is greater or equal than the sum of all ti. That means both Limak and Radewoosh will accept all n problems.
Input
The first line contains two integers n and c (1 ≤ n ≤ 50, 1 ≤ c ≤ 1000) — the number of problems and the constant representing the speed of loosing points.
The second line contains n integers p1, p2, ..., pn (1 ≤ pi ≤ 1000, pi < pi + 1) — initial scores.
The third line contains n integers t1, t2, ..., tn (1 ≤ ti ≤ 1000, ti < ti + 1) where ti denotes the number of minutes one needs to solve the i-th problem.
Output
Print "Limak" (without quotes) if Limak will get more points in total. Print "Radewoosh" (without quotes) if Radewoosh will get more points in total. Print "Tie" (without quotes) if Limak and Radewoosh will get the same total number of points.
Examples
Input
3 2
50 85 250
10 15 25
Output
Limak
Input
3 6
50 85 250
10 15 25
Output
Radewoosh
Input
8 1
10 20 30 40 50 60 70 80
8 10 58 63 71 72 75 76
Output
Tie
Note
In the first sample, there are 3 problems. Limak solves them as follows:
1. Limak spends 10 minutes on the 1-st problem and he gets 50 - c·10 = 50 - 2·10 = 30 points.
2. Limak spends 15 minutes on the 2-nd problem so he submits it 10 + 15 = 25 minutes after the start of the contest. For the 2-nd problem he gets 85 - 2·25 = 35 points.
3. He spends 25 minutes on the 3-rd problem so he submits it 10 + 15 + 25 = 50 minutes after the start. For this problem he gets 250 - 2·50 = 150 points.
So, Limak got 30 + 35 + 150 = 215 points.
Radewoosh solves problem in the reversed order:
1. Radewoosh solves 3-rd problem after 25 minutes so he gets 250 - 2·25 = 200 points.
2. He spends 15 minutes on the 2-nd problem so he submits it 25 + 15 = 40 minutes after the start. He gets 85 - 2·40 = 5 points for this problem.
3. He spends 10 minutes on the 1-st problem so he submits it 25 + 15 + 10 = 50 minutes after the start. He gets max(0, 50 - 2·50) = max(0, - 50) = 0 points.
Radewoosh got 200 + 5 + 0 = 205 points in total. Limak has 215 points so Limak wins.
In the second sample, Limak will get 0 points for each problem and Radewoosh will first solve the hardest problem and he will get 250 - 6·25 = 100 points for that. Radewoosh will get 0 points for other two problems but he is the winner anyway.
In the third sample, Limak will get 2 points for the 1-st problem and 2 points for the 2-nd problem. Radewoosh will get 4 points for the 8-th problem. They won't get points for other problems and thus there is a tie because 2 + 2 = 4.
Submitted Solution:
```
#-------------Program-------------
#----KuzlyaevNikita-Codeforces----
#
n,c=map(int,input().split())
p=list(map(int,input().split()))
t=list(map(int,input().split()))
limak=0;rade=0;time=0
for i in range(n):
time+=t[i]
limak+=max(0,p[i]-c*time)
time=0
for i in range(n-1,-1,-1):
time+=t[i]
rade+=max(0,p[i]-c*time)
if limak>rade:print('Limak')
elif limak==rade:print('Tie')
else:
print('Radewoosh')
``` | instruction | 0 | 39,146 | 11 | 78,292 |
Yes | output | 1 | 39,146 | 11 | 78,293 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
Limak and Radewoosh are going to compete against each other in the upcoming algorithmic contest. They are equally skilled but they won't solve problems in the same order.
There will be n problems. The i-th problem has initial score pi and it takes exactly ti minutes to solve it. Problems are sorted by difficulty — it's guaranteed that pi < pi + 1 and ti < ti + 1.
A constant c is given too, representing the speed of loosing points. Then, submitting the i-th problem at time x (x minutes after the start of the contest) gives max(0, pi - c·x) points.
Limak is going to solve problems in order 1, 2, ..., n (sorted increasingly by pi). Radewoosh is going to solve them in order n, n - 1, ..., 1 (sorted decreasingly by pi). Your task is to predict the outcome — print the name of the winner (person who gets more points at the end) or a word "Tie" in case of a tie.
You may assume that the duration of the competition is greater or equal than the sum of all ti. That means both Limak and Radewoosh will accept all n problems.
Input
The first line contains two integers n and c (1 ≤ n ≤ 50, 1 ≤ c ≤ 1000) — the number of problems and the constant representing the speed of loosing points.
The second line contains n integers p1, p2, ..., pn (1 ≤ pi ≤ 1000, pi < pi + 1) — initial scores.
The third line contains n integers t1, t2, ..., tn (1 ≤ ti ≤ 1000, ti < ti + 1) where ti denotes the number of minutes one needs to solve the i-th problem.
Output
Print "Limak" (without quotes) if Limak will get more points in total. Print "Radewoosh" (without quotes) if Radewoosh will get more points in total. Print "Tie" (without quotes) if Limak and Radewoosh will get the same total number of points.
Examples
Input
3 2
50 85 250
10 15 25
Output
Limak
Input
3 6
50 85 250
10 15 25
Output
Radewoosh
Input
8 1
10 20 30 40 50 60 70 80
8 10 58 63 71 72 75 76
Output
Tie
Note
In the first sample, there are 3 problems. Limak solves them as follows:
1. Limak spends 10 minutes on the 1-st problem and he gets 50 - c·10 = 50 - 2·10 = 30 points.
2. Limak spends 15 minutes on the 2-nd problem so he submits it 10 + 15 = 25 minutes after the start of the contest. For the 2-nd problem he gets 85 - 2·25 = 35 points.
3. He spends 25 minutes on the 3-rd problem so he submits it 10 + 15 + 25 = 50 minutes after the start. For this problem he gets 250 - 2·50 = 150 points.
So, Limak got 30 + 35 + 150 = 215 points.
Radewoosh solves problem in the reversed order:
1. Radewoosh solves 3-rd problem after 25 minutes so he gets 250 - 2·25 = 200 points.
2. He spends 15 minutes on the 2-nd problem so he submits it 25 + 15 = 40 minutes after the start. He gets 85 - 2·40 = 5 points for this problem.
3. He spends 10 minutes on the 1-st problem so he submits it 25 + 15 + 10 = 50 minutes after the start. He gets max(0, 50 - 2·50) = max(0, - 50) = 0 points.
Radewoosh got 200 + 5 + 0 = 205 points in total. Limak has 215 points so Limak wins.
In the second sample, Limak will get 0 points for each problem and Radewoosh will first solve the hardest problem and he will get 250 - 6·25 = 100 points for that. Radewoosh will get 0 points for other two problems but he is the winner anyway.
In the third sample, Limak will get 2 points for the 1-st problem and 2 points for the 2-nd problem. Radewoosh will get 4 points for the 8-th problem. They won't get points for other problems and thus there is a tie because 2 + 2 = 4.
Submitted Solution:
```
l = list(input().split())
n = int(l[0])
c = int(l[1])
points = list(input().split())
points = [int(i) for i in points]
time = list(input().split())
time = [int(i) for i in time]
sumtime = 0
limak = 0
redwoosh = 0
for i in range(n):
sumtime += time[i]
limak += max(0, (points[i] - (c * sumtime)))
sumtime = 0
for i in range(n-1, -1, -1):
sumtime += time[i]
redwoosh += max((points[i] - (c * sumtime)), 0)
if limak > redwoosh:
print("Limak")
elif limak < redwoosh:
print("Redwoosh")
else:
print("Tie")
``` | instruction | 0 | 39,147 | 11 | 78,294 |
No | output | 1 | 39,147 | 11 | 78,295 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
Limak and Radewoosh are going to compete against each other in the upcoming algorithmic contest. They are equally skilled but they won't solve problems in the same order.
There will be n problems. The i-th problem has initial score pi and it takes exactly ti minutes to solve it. Problems are sorted by difficulty — it's guaranteed that pi < pi + 1 and ti < ti + 1.
A constant c is given too, representing the speed of loosing points. Then, submitting the i-th problem at time x (x minutes after the start of the contest) gives max(0, pi - c·x) points.
Limak is going to solve problems in order 1, 2, ..., n (sorted increasingly by pi). Radewoosh is going to solve them in order n, n - 1, ..., 1 (sorted decreasingly by pi). Your task is to predict the outcome — print the name of the winner (person who gets more points at the end) or a word "Tie" in case of a tie.
You may assume that the duration of the competition is greater or equal than the sum of all ti. That means both Limak and Radewoosh will accept all n problems.
Input
The first line contains two integers n and c (1 ≤ n ≤ 50, 1 ≤ c ≤ 1000) — the number of problems and the constant representing the speed of loosing points.
The second line contains n integers p1, p2, ..., pn (1 ≤ pi ≤ 1000, pi < pi + 1) — initial scores.
The third line contains n integers t1, t2, ..., tn (1 ≤ ti ≤ 1000, ti < ti + 1) where ti denotes the number of minutes one needs to solve the i-th problem.
Output
Print "Limak" (without quotes) if Limak will get more points in total. Print "Radewoosh" (without quotes) if Radewoosh will get more points in total. Print "Tie" (without quotes) if Limak and Radewoosh will get the same total number of points.
Examples
Input
3 2
50 85 250
10 15 25
Output
Limak
Input
3 6
50 85 250
10 15 25
Output
Radewoosh
Input
8 1
10 20 30 40 50 60 70 80
8 10 58 63 71 72 75 76
Output
Tie
Note
In the first sample, there are 3 problems. Limak solves them as follows:
1. Limak spends 10 minutes on the 1-st problem and he gets 50 - c·10 = 50 - 2·10 = 30 points.
2. Limak spends 15 minutes on the 2-nd problem so he submits it 10 + 15 = 25 minutes after the start of the contest. For the 2-nd problem he gets 85 - 2·25 = 35 points.
3. He spends 25 minutes on the 3-rd problem so he submits it 10 + 15 + 25 = 50 minutes after the start. For this problem he gets 250 - 2·50 = 150 points.
So, Limak got 30 + 35 + 150 = 215 points.
Radewoosh solves problem in the reversed order:
1. Radewoosh solves 3-rd problem after 25 minutes so he gets 250 - 2·25 = 200 points.
2. He spends 15 minutes on the 2-nd problem so he submits it 25 + 15 = 40 minutes after the start. He gets 85 - 2·40 = 5 points for this problem.
3. He spends 10 minutes on the 1-st problem so he submits it 25 + 15 + 10 = 50 minutes after the start. He gets max(0, 50 - 2·50) = max(0, - 50) = 0 points.
Radewoosh got 200 + 5 + 0 = 205 points in total. Limak has 215 points so Limak wins.
In the second sample, Limak will get 0 points for each problem and Radewoosh will first solve the hardest problem and he will get 250 - 6·25 = 100 points for that. Radewoosh will get 0 points for other two problems but he is the winner anyway.
In the third sample, Limak will get 2 points for the 1-st problem and 2 points for the 2-nd problem. Radewoosh will get 4 points for the 8-th problem. They won't get points for other problems and thus there is a tie because 2 + 2 = 4.
Submitted Solution:
```
n,c=list(map(int,input().split()))
a=list(map(int,input().split()))
b=list(map(int,input().split()))
Limak,Radewoosh=0,0
if len(a)==1:
print('Tie')
else:
for i in range(len(a)):
Limak+=max([0,a[i]-c*sum(b[0:i+1])])
for j in range(len(a)-1,0,-1):
Radewoosh+=max([0,a[j]-c*sum(b[j::])])
print(b[j::])
if Limak>Radewoosh:
print('Limak')
elif Radewoosh>Limak:
print('Radewoosh')
else:
print('Tie')
``` | instruction | 0 | 39,148 | 11 | 78,296 |
No | output | 1 | 39,148 | 11 | 78,297 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
Limak and Radewoosh are going to compete against each other in the upcoming algorithmic contest. They are equally skilled but they won't solve problems in the same order.
There will be n problems. The i-th problem has initial score pi and it takes exactly ti minutes to solve it. Problems are sorted by difficulty — it's guaranteed that pi < pi + 1 and ti < ti + 1.
A constant c is given too, representing the speed of loosing points. Then, submitting the i-th problem at time x (x minutes after the start of the contest) gives max(0, pi - c·x) points.
Limak is going to solve problems in order 1, 2, ..., n (sorted increasingly by pi). Radewoosh is going to solve them in order n, n - 1, ..., 1 (sorted decreasingly by pi). Your task is to predict the outcome — print the name of the winner (person who gets more points at the end) or a word "Tie" in case of a tie.
You may assume that the duration of the competition is greater or equal than the sum of all ti. That means both Limak and Radewoosh will accept all n problems.
Input
The first line contains two integers n and c (1 ≤ n ≤ 50, 1 ≤ c ≤ 1000) — the number of problems and the constant representing the speed of loosing points.
The second line contains n integers p1, p2, ..., pn (1 ≤ pi ≤ 1000, pi < pi + 1) — initial scores.
The third line contains n integers t1, t2, ..., tn (1 ≤ ti ≤ 1000, ti < ti + 1) where ti denotes the number of minutes one needs to solve the i-th problem.
Output
Print "Limak" (without quotes) if Limak will get more points in total. Print "Radewoosh" (without quotes) if Radewoosh will get more points in total. Print "Tie" (without quotes) if Limak and Radewoosh will get the same total number of points.
Examples
Input
3 2
50 85 250
10 15 25
Output
Limak
Input
3 6
50 85 250
10 15 25
Output
Radewoosh
Input
8 1
10 20 30 40 50 60 70 80
8 10 58 63 71 72 75 76
Output
Tie
Note
In the first sample, there are 3 problems. Limak solves them as follows:
1. Limak spends 10 minutes on the 1-st problem and he gets 50 - c·10 = 50 - 2·10 = 30 points.
2. Limak spends 15 minutes on the 2-nd problem so he submits it 10 + 15 = 25 minutes after the start of the contest. For the 2-nd problem he gets 85 - 2·25 = 35 points.
3. He spends 25 minutes on the 3-rd problem so he submits it 10 + 15 + 25 = 50 minutes after the start. For this problem he gets 250 - 2·50 = 150 points.
So, Limak got 30 + 35 + 150 = 215 points.
Radewoosh solves problem in the reversed order:
1. Radewoosh solves 3-rd problem after 25 minutes so he gets 250 - 2·25 = 200 points.
2. He spends 15 minutes on the 2-nd problem so he submits it 25 + 15 = 40 minutes after the start. He gets 85 - 2·40 = 5 points for this problem.
3. He spends 10 minutes on the 1-st problem so he submits it 25 + 15 + 10 = 50 minutes after the start. He gets max(0, 50 - 2·50) = max(0, - 50) = 0 points.
Radewoosh got 200 + 5 + 0 = 205 points in total. Limak has 215 points so Limak wins.
In the second sample, Limak will get 0 points for each problem and Radewoosh will first solve the hardest problem and he will get 250 - 6·25 = 100 points for that. Radewoosh will get 0 points for other two problems but he is the winner anyway.
In the third sample, Limak will get 2 points for the 1-st problem and 2 points for the 2-nd problem. Radewoosh will get 4 points for the 8-th problem. They won't get points for other problems and thus there is a tie because 2 + 2 = 4.
Submitted Solution:
```
n,c = map(int,input().split())
p = list(map(int,input().split()))
t = list(map(int,input().split()))
l_point = 0
def point(debut,fin,pas):
liste = []
a = 0
for i in range(debut,fin,pas):
a += t[i]
liste.append(max(0,p[i]-a*c))
return sum(liste)
l_point = point(0,n,1)
r_points = point(n-1,0,-1)
if l_point > r_points:
print('Limak')
elif l_point < r_points:
print('Radewoosh')
else:
print('Tie')
``` | instruction | 0 | 39,149 | 11 | 78,298 |
No | output | 1 | 39,149 | 11 | 78,299 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
Limak and Radewoosh are going to compete against each other in the upcoming algorithmic contest. They are equally skilled but they won't solve problems in the same order.
There will be n problems. The i-th problem has initial score pi and it takes exactly ti minutes to solve it. Problems are sorted by difficulty — it's guaranteed that pi < pi + 1 and ti < ti + 1.
A constant c is given too, representing the speed of loosing points. Then, submitting the i-th problem at time x (x minutes after the start of the contest) gives max(0, pi - c·x) points.
Limak is going to solve problems in order 1, 2, ..., n (sorted increasingly by pi). Radewoosh is going to solve them in order n, n - 1, ..., 1 (sorted decreasingly by pi). Your task is to predict the outcome — print the name of the winner (person who gets more points at the end) or a word "Tie" in case of a tie.
You may assume that the duration of the competition is greater or equal than the sum of all ti. That means both Limak and Radewoosh will accept all n problems.
Input
The first line contains two integers n and c (1 ≤ n ≤ 50, 1 ≤ c ≤ 1000) — the number of problems and the constant representing the speed of loosing points.
The second line contains n integers p1, p2, ..., pn (1 ≤ pi ≤ 1000, pi < pi + 1) — initial scores.
The third line contains n integers t1, t2, ..., tn (1 ≤ ti ≤ 1000, ti < ti + 1) where ti denotes the number of minutes one needs to solve the i-th problem.
Output
Print "Limak" (without quotes) if Limak will get more points in total. Print "Radewoosh" (without quotes) if Radewoosh will get more points in total. Print "Tie" (without quotes) if Limak and Radewoosh will get the same total number of points.
Examples
Input
3 2
50 85 250
10 15 25
Output
Limak
Input
3 6
50 85 250
10 15 25
Output
Radewoosh
Input
8 1
10 20 30 40 50 60 70 80
8 10 58 63 71 72 75 76
Output
Tie
Note
In the first sample, there are 3 problems. Limak solves them as follows:
1. Limak spends 10 minutes on the 1-st problem and he gets 50 - c·10 = 50 - 2·10 = 30 points.
2. Limak spends 15 minutes on the 2-nd problem so he submits it 10 + 15 = 25 minutes after the start of the contest. For the 2-nd problem he gets 85 - 2·25 = 35 points.
3. He spends 25 minutes on the 3-rd problem so he submits it 10 + 15 + 25 = 50 minutes after the start. For this problem he gets 250 - 2·50 = 150 points.
So, Limak got 30 + 35 + 150 = 215 points.
Radewoosh solves problem in the reversed order:
1. Radewoosh solves 3-rd problem after 25 minutes so he gets 250 - 2·25 = 200 points.
2. He spends 15 minutes on the 2-nd problem so he submits it 25 + 15 = 40 minutes after the start. He gets 85 - 2·40 = 5 points for this problem.
3. He spends 10 minutes on the 1-st problem so he submits it 25 + 15 + 10 = 50 minutes after the start. He gets max(0, 50 - 2·50) = max(0, - 50) = 0 points.
Radewoosh got 200 + 5 + 0 = 205 points in total. Limak has 215 points so Limak wins.
In the second sample, Limak will get 0 points for each problem and Radewoosh will first solve the hardest problem and he will get 250 - 6·25 = 100 points for that. Radewoosh will get 0 points for other two problems but he is the winner anyway.
In the third sample, Limak will get 2 points for the 1-st problem and 2 points for the 2-nd problem. Radewoosh will get 4 points for the 8-th problem. They won't get points for other problems and thus there is a tie because 2 + 2 = 4.
Submitted Solution:
```
n, c = list(map(int, input().split()))
p = list(map(int, input().split()))
t = list(map(int, input().split()))
fi = 0
se = 0
ti = 0
for i in range(n):
fi += max(0, p[i] - c * ti)
ti += t[i]
ti = 0
for i in range(n - 1, 0):
se += max(0, p[i] - c * ti)
ti += t[i]
ret = ["Limak", "Radewoosh", "Tie"]
pos = 2
if fi > se:
pos = 0
elif fi < se:
pos = 1
print(ret[pos])
``` | instruction | 0 | 39,150 | 11 | 78,300 |
No | output | 1 | 39,150 | 11 | 78,301 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
There are N people numbered 1 to N. Each of them is either an honest person whose testimonies are always correct or an unkind person whose testimonies may be correct or not.
Person i gives A_i testimonies. The j-th testimony by Person i is represented by two integers x_{ij} and y_{ij}. If y_{ij} = 1, the testimony says Person x_{ij} is honest; if y_{ij} = 0, it says Person x_{ij} is unkind.
How many honest persons can be among those N people at most?
Constraints
* All values in input are integers.
* 1 \leq N \leq 15
* 0 \leq A_i \leq N - 1
* 1 \leq x_{ij} \leq N
* x_{ij} \neq i
* x_{ij_1} \neq x_{ij_2} (j_1 \neq j_2)
* y_{ij} = 0, 1
Input
Input is given from Standard Input in the following format:
N
A_1
x_{11} y_{11}
x_{12} y_{12}
:
x_{1A_1} y_{1A_1}
A_2
x_{21} y_{21}
x_{22} y_{22}
:
x_{2A_2} y_{2A_2}
:
A_N
x_{N1} y_{N1}
x_{N2} y_{N2}
:
x_{NA_N} y_{NA_N}
Output
Print the maximum possible number of honest persons among the N people.
Examples
Input
3
1
2 1
1
1 1
1
2 0
Output
2
Input
3
2
2 1
3 0
2
3 1
1 0
2
1 1
2 0
Output
0
Input
2
1
2 0
1
1 0
Output
1
Submitted Solution:
```
from itertools import combinations
n = int(input())
l = (1 << n) - 1
r = range(n)
a = [[0, 0] for _ in r]
for i in r:
for _ in range(int(input())):
x, y = map(int, input().split())
a[i][y] |= 1 << x - 1
def fail(x):
x = sum(1 << i for i in x)
return not all(a[i][0] & x == a[i][1] & l - x == 0 for i in r if x >> i & 1)
while all(map(fail, combinations(r, n))):
n -= 1
print(n)
``` | instruction | 0 | 39,406 | 11 | 78,812 |
Yes | output | 1 | 39,406 | 11 | 78,813 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
There are N people numbered 1 to N. Each of them is either an honest person whose testimonies are always correct or an unkind person whose testimonies may be correct or not.
Person i gives A_i testimonies. The j-th testimony by Person i is represented by two integers x_{ij} and y_{ij}. If y_{ij} = 1, the testimony says Person x_{ij} is honest; if y_{ij} = 0, it says Person x_{ij} is unkind.
How many honest persons can be among those N people at most?
Constraints
* All values in input are integers.
* 1 \leq N \leq 15
* 0 \leq A_i \leq N - 1
* 1 \leq x_{ij} \leq N
* x_{ij} \neq i
* x_{ij_1} \neq x_{ij_2} (j_1 \neq j_2)
* y_{ij} = 0, 1
Input
Input is given from Standard Input in the following format:
N
A_1
x_{11} y_{11}
x_{12} y_{12}
:
x_{1A_1} y_{1A_1}
A_2
x_{21} y_{21}
x_{22} y_{22}
:
x_{2A_2} y_{2A_2}
:
A_N
x_{N1} y_{N1}
x_{N2} y_{N2}
:
x_{NA_N} y_{NA_N}
Output
Print the maximum possible number of honest persons among the N people.
Examples
Input
3
1
2 1
1
1 1
1
2 0
Output
2
Input
3
2
2 1
3 0
2
3 1
1 0
2
1 1
2 0
Output
0
Input
2
1
2 0
1
1 0
Output
1
Submitted Solution:
```
def popcount(x):
r = 0
while x:
r += 1
x &= x - 1
return r
n = int(input())
r = range(n)
a = [[0, 0] for _ in r]
for i in r:
for _ in range(int(input())):
x, y = map(int, input().split())
a[i][y] |= 1 << (x - 1)
m = 0
l = (1 << n) - 1
for x in range(1, l + 1):
if all(a[i][0] & x == a[i][1] & l - x == 0 for i in r if x >> i & 1):
m = max(m, popcount(x))
print(m)
``` | instruction | 0 | 39,407 | 11 | 78,814 |
Yes | output | 1 | 39,407 | 11 | 78,815 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
There are N people numbered 1 to N. Each of them is either an honest person whose testimonies are always correct or an unkind person whose testimonies may be correct or not.
Person i gives A_i testimonies. The j-th testimony by Person i is represented by two integers x_{ij} and y_{ij}. If y_{ij} = 1, the testimony says Person x_{ij} is honest; if y_{ij} = 0, it says Person x_{ij} is unkind.
How many honest persons can be among those N people at most?
Constraints
* All values in input are integers.
* 1 \leq N \leq 15
* 0 \leq A_i \leq N - 1
* 1 \leq x_{ij} \leq N
* x_{ij} \neq i
* x_{ij_1} \neq x_{ij_2} (j_1 \neq j_2)
* y_{ij} = 0, 1
Input
Input is given from Standard Input in the following format:
N
A_1
x_{11} y_{11}
x_{12} y_{12}
:
x_{1A_1} y_{1A_1}
A_2
x_{21} y_{21}
x_{22} y_{22}
:
x_{2A_2} y_{2A_2}
:
A_N
x_{N1} y_{N1}
x_{N2} y_{N2}
:
x_{NA_N} y_{NA_N}
Output
Print the maximum possible number of honest persons among the N people.
Examples
Input
3
1
2 1
1
1 1
1
2 0
Output
2
Input
3
2
2 1
3 0
2
3 1
1 0
2
1 1
2 0
Output
0
Input
2
1
2 0
1
1 0
Output
1
Submitted Solution:
```
from itertools import combinations, count
n = int(input())
r = range(n)
a = [(set(), set()) for _ in r]
for i in r:
for _ in range(int(input())):
x, y = map(int, input().split())
a[i][y].add(x - 1)
r = next(i for i in count(n, -1) for x in map(set, combinations(r, i))
if all(a[j][0].isdisjoint(x) and a[j][1].issubset(x) for j in x))
print(r)
``` | instruction | 0 | 39,408 | 11 | 78,816 |
Yes | output | 1 | 39,408 | 11 | 78,817 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
There are N people numbered 1 to N. Each of them is either an honest person whose testimonies are always correct or an unkind person whose testimonies may be correct or not.
Person i gives A_i testimonies. The j-th testimony by Person i is represented by two integers x_{ij} and y_{ij}. If y_{ij} = 1, the testimony says Person x_{ij} is honest; if y_{ij} = 0, it says Person x_{ij} is unkind.
How many honest persons can be among those N people at most?
Constraints
* All values in input are integers.
* 1 \leq N \leq 15
* 0 \leq A_i \leq N - 1
* 1 \leq x_{ij} \leq N
* x_{ij} \neq i
* x_{ij_1} \neq x_{ij_2} (j_1 \neq j_2)
* y_{ij} = 0, 1
Input
Input is given from Standard Input in the following format:
N
A_1
x_{11} y_{11}
x_{12} y_{12}
:
x_{1A_1} y_{1A_1}
A_2
x_{21} y_{21}
x_{22} y_{22}
:
x_{2A_2} y_{2A_2}
:
A_N
x_{N1} y_{N1}
x_{N2} y_{N2}
:
x_{NA_N} y_{NA_N}
Output
Print the maximum possible number of honest persons among the N people.
Examples
Input
3
1
2 1
1
1 1
1
2 0
Output
2
Input
3
2
2 1
3 0
2
3 1
1 0
2
1 1
2 0
Output
0
Input
2
1
2 0
1
1 0
Output
1
Submitted Solution:
```
n = int(input())
v = [[tuple(map(int, input().split()))for i in range(int(input()))]
for i in range(n)]
ans = 0
for i in range(2**n):
f = True
a = 0
for j in range(n):
if (i >> j) & 1:
if all(i >> (x - 1) & 1 == y for x, y in v[j]):
a += 1
else:
f = False
break
if f:
ans = max(ans, a)
print(ans)
``` | instruction | 0 | 39,409 | 11 | 78,818 |
Yes | output | 1 | 39,409 | 11 | 78,819 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
There are N people numbered 1 to N. Each of them is either an honest person whose testimonies are always correct or an unkind person whose testimonies may be correct or not.
Person i gives A_i testimonies. The j-th testimony by Person i is represented by two integers x_{ij} and y_{ij}. If y_{ij} = 1, the testimony says Person x_{ij} is honest; if y_{ij} = 0, it says Person x_{ij} is unkind.
How many honest persons can be among those N people at most?
Constraints
* All values in input are integers.
* 1 \leq N \leq 15
* 0 \leq A_i \leq N - 1
* 1 \leq x_{ij} \leq N
* x_{ij} \neq i
* x_{ij_1} \neq x_{ij_2} (j_1 \neq j_2)
* y_{ij} = 0, 1
Input
Input is given from Standard Input in the following format:
N
A_1
x_{11} y_{11}
x_{12} y_{12}
:
x_{1A_1} y_{1A_1}
A_2
x_{21} y_{21}
x_{22} y_{22}
:
x_{2A_2} y_{2A_2}
:
A_N
x_{N1} y_{N1}
x_{N2} y_{N2}
:
x_{NA_N} y_{NA_N}
Output
Print the maximum possible number of honest persons among the N people.
Examples
Input
3
1
2 1
1
1 1
1
2 0
Output
2
Input
3
2
2 1
3 0
2
3 1
1 0
2
1 1
2 0
Output
0
Input
2
1
2 0
1
1 0
Output
1
Submitted Solution:
```
# -*- coding: utf-8 -*-
"""
Created on Fri Mar 13 21:55:08 2020
@author: Kanaru Sato
"""
n = int(input())
a = []
proof = []
for i in range(n):
a.append(int(input()))
p = [list(map(int, input().split())) for j in range(a[-1])]
proof.append(p)
honest = 0
for state in range(2**n): #状態stateを用意
flag = 0
for j in range(n):
if int(bin(state>>j & 0b1),2) == 1: #状態stateにおいてj人目が正直か判定
for k in range(a[j]):
if int(bin((state >> proof[j][k][0]) & 0b1),2) != proof[j][k][1]: #j人目のK番目の証言について、stateと一致しなければ次のstateへ移る
flag = 1 #不成立フラグ
if flag == 0:
count = 0
for i in range(n):
count += int(bin((state >> i) & 0b1), 2)
if honest <= count:
honest = count
print(honest)
``` | instruction | 0 | 39,410 | 11 | 78,820 |
No | output | 1 | 39,410 | 11 | 78,821 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
There are N people numbered 1 to N. Each of them is either an honest person whose testimonies are always correct or an unkind person whose testimonies may be correct or not.
Person i gives A_i testimonies. The j-th testimony by Person i is represented by two integers x_{ij} and y_{ij}. If y_{ij} = 1, the testimony says Person x_{ij} is honest; if y_{ij} = 0, it says Person x_{ij} is unkind.
How many honest persons can be among those N people at most?
Constraints
* All values in input are integers.
* 1 \leq N \leq 15
* 0 \leq A_i \leq N - 1
* 1 \leq x_{ij} \leq N
* x_{ij} \neq i
* x_{ij_1} \neq x_{ij_2} (j_1 \neq j_2)
* y_{ij} = 0, 1
Input
Input is given from Standard Input in the following format:
N
A_1
x_{11} y_{11}
x_{12} y_{12}
:
x_{1A_1} y_{1A_1}
A_2
x_{21} y_{21}
x_{22} y_{22}
:
x_{2A_2} y_{2A_2}
:
A_N
x_{N1} y_{N1}
x_{N2} y_{N2}
:
x_{NA_N} y_{NA_N}
Output
Print the maximum possible number of honest persons among the N people.
Examples
Input
3
1
2 1
1
1 1
1
2 0
Output
2
Input
3
2
2 1
3 0
2
3 1
1 0
2
1 1
2 0
Output
0
Input
2
1
2 0
1
1 0
Output
1
Submitted Solution:
```
n=int(input())
test=[[-1]*15]*15
for i in range(n):
a=int(input())
if a:
for j in range(a):
x,y=map(int,input().split())
x-=1
test[i][x]=y
Num=[0]
for i in range(1,(2**n)):
i=bin(i)
s=str(i)
s=list(s)
s=s[2:]
s.reverse()
if (len(s))!=n:
for i in range(n-len(s)):
s.append('0')
s.reverse()
lst=[]
Lst=[]
for j in range(len(s)):
t=s[j]
lst.append(int(t))
for k in range(n):
if lst[k]:
Lst.append(test[k])
Lst_2=[[] for _ in range(n)]
for N in range(15):
for m in range(len(Lst)):
Lst_2[m].append(Lst[m][N])
Lst_2[m].append(-1)
for I in range(len(Lst_2)):
if len(set(Lst_2[I])-set([-1]))>1:
break
if I==len(Lst_2)-1 and len(set(Lst_2[I])-set([-1]))<=1:
Num.append(list(s).count('1'))
print(max(Num))
``` | instruction | 0 | 39,411 | 11 | 78,822 |
No | output | 1 | 39,411 | 11 | 78,823 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
There are N people numbered 1 to N. Each of them is either an honest person whose testimonies are always correct or an unkind person whose testimonies may be correct or not.
Person i gives A_i testimonies. The j-th testimony by Person i is represented by two integers x_{ij} and y_{ij}. If y_{ij} = 1, the testimony says Person x_{ij} is honest; if y_{ij} = 0, it says Person x_{ij} is unkind.
How many honest persons can be among those N people at most?
Constraints
* All values in input are integers.
* 1 \leq N \leq 15
* 0 \leq A_i \leq N - 1
* 1 \leq x_{ij} \leq N
* x_{ij} \neq i
* x_{ij_1} \neq x_{ij_2} (j_1 \neq j_2)
* y_{ij} = 0, 1
Input
Input is given from Standard Input in the following format:
N
A_1
x_{11} y_{11}
x_{12} y_{12}
:
x_{1A_1} y_{1A_1}
A_2
x_{21} y_{21}
x_{22} y_{22}
:
x_{2A_2} y_{2A_2}
:
A_N
x_{N1} y_{N1}
x_{N2} y_{N2}
:
x_{NA_N} y_{NA_N}
Output
Print the maximum possible number of honest persons among the N people.
Examples
Input
3
1
2 1
1
1 1
1
2 0
Output
2
Input
3
2
2 1
3 0
2
3 1
1 0
2
1 1
2 0
Output
0
Input
2
1
2 0
1
1 0
Output
1
Submitted Solution:
```
N = int(input())
testimony = [[] for _ in range(N)]
#print(testimony)
for i in range(N):
num = int(input())
for j in range(num):
person, state = map(int, input().split())
testimony[i].append([person-1, state])
#print(testimony)
honest = 0
for i in range(i, 2**N):
flag = 0
for j in range(N):
if (i>>j)&1 == 1:
for x, y in testimony[j]:
if (i>>x)&1 != y:
flag = 1
break
if flag == 0:
honest = max(honest, bin(i)[2:].count('1'))
print(honest)
``` | instruction | 0 | 39,412 | 11 | 78,824 |
No | output | 1 | 39,412 | 11 | 78,825 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
There are N people numbered 1 to N. Each of them is either an honest person whose testimonies are always correct or an unkind person whose testimonies may be correct or not.
Person i gives A_i testimonies. The j-th testimony by Person i is represented by two integers x_{ij} and y_{ij}. If y_{ij} = 1, the testimony says Person x_{ij} is honest; if y_{ij} = 0, it says Person x_{ij} is unkind.
How many honest persons can be among those N people at most?
Constraints
* All values in input are integers.
* 1 \leq N \leq 15
* 0 \leq A_i \leq N - 1
* 1 \leq x_{ij} \leq N
* x_{ij} \neq i
* x_{ij_1} \neq x_{ij_2} (j_1 \neq j_2)
* y_{ij} = 0, 1
Input
Input is given from Standard Input in the following format:
N
A_1
x_{11} y_{11}
x_{12} y_{12}
:
x_{1A_1} y_{1A_1}
A_2
x_{21} y_{21}
x_{22} y_{22}
:
x_{2A_2} y_{2A_2}
:
A_N
x_{N1} y_{N1}
x_{N2} y_{N2}
:
x_{NA_N} y_{NA_N}
Output
Print the maximum possible number of honest persons among the N people.
Examples
Input
3
1
2 1
1
1 1
1
2 0
Output
2
Input
3
2
2 1
3 0
2
3 1
1 0
2
1 1
2 0
Output
0
Input
2
1
2 0
1
1 0
Output
1
Submitted Solution:
```
N = int(input())
A = []
for _ in range(N):
a = int(input())
A.append([[int(x) for x in input().split()] for _ in range(a)])
ans = 0
for i in range(2**N):
indexes = [j for j in range(N) if i & (1 << j)]
expects = set([j + 1 for j in indexes])
alist = [A[j] for j in indexes]
valid = True
honests = set()
liars = set()
for a in alist:
for (index, is_honest) in a:
if is_honest == 1:
honests.add(index)
else:
liars.add(index)
if not honests & liars:
if honests & expects:
ans = max(ans, len(honests))
elif liars & expects:
ans = max(ans, 1)
print(ans)
``` | instruction | 0 | 39,413 | 11 | 78,826 |
No | output | 1 | 39,413 | 11 | 78,827 |
Provide a correct Python 3 solution for this coding contest problem.
Example
Input
8 5
1 2
6 5
6 4
1 3
4 7
Output
11 | instruction | 0 | 39,566 | 11 | 79,132 |
"Correct Solution:
```
from collections import deque
import sys
readline = sys.stdin.readline
write = sys.stdout.write
def solve():
N, M = map(int, readline().split())
G = [[] for i in range(N)]
for i in range(M):
a, b = map(int, readline().split())
G[a-1].append(b-1)
G[b-1].append(a-1)
col = [-1]*N
C = {}
L0 = 0
L = 0
for i in range(N):
if col[i] != -1:
continue
que = deque([i])
col[i] = 0
cs = [1, 0]
while que:
v = que.popleft()
c = col[v]^1
for w in G[v]:
if col[w] != -1:
if col[w] != c:
write("-1\n")
return
else:
col[w] = c
cs[c] += 1
que.append(w)
e = abs(cs[1] - cs[0])
L += e
if e > 0:
C[e] = C.get(e, 0) + 1
W = L//2
dp = [0]*(W+1)
dp[0] = 1
for v, c in C.items():
for b in range(v):
s = 0
k0 = (W - b) // v * v + b
for i in range(c):
if k0-v*i >= 0:
s += dp[k0-v*i]
for k in range(k0, -1, -v):
s -= dp[k]
if k-c*v >= 0:
s += dp[k-c*v]
if s:
dp[k] = 1
k = 0
for i in range(W, -1, -1):
if dp[i]:
k = i
break
A = (N - L) // 2 + k
B = (N - L) // 2 + L - k
write("%d\n" % (A*B - M))
solve()
``` | output | 1 | 39,566 | 11 | 79,133 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
The average miner Vaganych took refresher courses. As soon as a miner completes the courses, he should take exams. The hardest one is a computer test called "Testing Pants for Sadness".
The test consists of n questions; the questions are to be answered strictly in the order in which they are given, from question 1 to question n. Question i contains ai answer variants, exactly one of them is correct.
A click is regarded as selecting any answer in any question. The goal is to select the correct answer for each of the n questions. If Vaganych selects a wrong answer for some question, then all selected answers become unselected and the test starts from the very beginning, from question 1 again. But Vaganych remembers everything. The order of answers for each question and the order of questions remain unchanged, as well as the question and answers themselves.
Vaganych is very smart and his memory is superb, yet he is unbelievably unlucky and knows nothing whatsoever about the test's theme. How many clicks will he have to perform in the worst case?
Input
The first line contains a positive integer n (1 ≤ n ≤ 100). It is the number of questions in the test. The second line contains space-separated n positive integers ai (1 ≤ ai ≤ 109), the number of answer variants to question i.
Output
Print a single number — the minimal number of clicks needed to pass the test it the worst-case scenario.
Please do not use the %lld specificator to read or write 64-bit integers in С++. It is preferred to use the cin, cout streams or the %I64d specificator.
Examples
Input
2
1 1
Output
2
Input
2
2 2
Output
5
Input
1
10
Output
10
Note
Note to the second sample. In the worst-case scenario you will need five clicks:
* the first click selects the first variant to the first question, this answer turns out to be wrong.
* the second click selects the second variant to the first question, it proves correct and we move on to the second question;
* the third click selects the first variant to the second question, it is wrong and we go back to question 1;
* the fourth click selects the second variant to the first question, it proves as correct as it was and we move on to the second question;
* the fifth click selects the second variant to the second question, it proves correct, the test is finished.
Submitted Solution:
```
n=int(input())
ar=list(map(int,input().split()))
ans=0
for i in range(n):
ans+=(i+1)*(ar[i]-1)+(i+1)-i
print(ans)
``` | instruction | 0 | 39,624 | 11 | 79,248 |
Yes | output | 1 | 39,624 | 11 | 79,249 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
The average miner Vaganych took refresher courses. As soon as a miner completes the courses, he should take exams. The hardest one is a computer test called "Testing Pants for Sadness".
The test consists of n questions; the questions are to be answered strictly in the order in which they are given, from question 1 to question n. Question i contains ai answer variants, exactly one of them is correct.
A click is regarded as selecting any answer in any question. The goal is to select the correct answer for each of the n questions. If Vaganych selects a wrong answer for some question, then all selected answers become unselected and the test starts from the very beginning, from question 1 again. But Vaganych remembers everything. The order of answers for each question and the order of questions remain unchanged, as well as the question and answers themselves.
Vaganych is very smart and his memory is superb, yet he is unbelievably unlucky and knows nothing whatsoever about the test's theme. How many clicks will he have to perform in the worst case?
Input
The first line contains a positive integer n (1 ≤ n ≤ 100). It is the number of questions in the test. The second line contains space-separated n positive integers ai (1 ≤ ai ≤ 109), the number of answer variants to question i.
Output
Print a single number — the minimal number of clicks needed to pass the test it the worst-case scenario.
Please do not use the %lld specificator to read or write 64-bit integers in С++. It is preferred to use the cin, cout streams or the %I64d specificator.
Examples
Input
2
1 1
Output
2
Input
2
2 2
Output
5
Input
1
10
Output
10
Note
Note to the second sample. In the worst-case scenario you will need five clicks:
* the first click selects the first variant to the first question, this answer turns out to be wrong.
* the second click selects the second variant to the first question, it proves correct and we move on to the second question;
* the third click selects the first variant to the second question, it is wrong and we go back to question 1;
* the fourth click selects the second variant to the first question, it proves as correct as it was and we move on to the second question;
* the fifth click selects the second variant to the second question, it proves correct, the test is finished.
Submitted Solution:
```
def shtany(lst):
count = 0
for i in range(len(lst)):
count += (lst[i] - 1) * (i + 1) + 1
return count
n = int(input())
a = [int(j) for j in input().split()]
print(shtany(a))
``` | instruction | 0 | 39,625 | 11 | 79,250 |
Yes | output | 1 | 39,625 | 11 | 79,251 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
The average miner Vaganych took refresher courses. As soon as a miner completes the courses, he should take exams. The hardest one is a computer test called "Testing Pants for Sadness".
The test consists of n questions; the questions are to be answered strictly in the order in which they are given, from question 1 to question n. Question i contains ai answer variants, exactly one of them is correct.
A click is regarded as selecting any answer in any question. The goal is to select the correct answer for each of the n questions. If Vaganych selects a wrong answer for some question, then all selected answers become unselected and the test starts from the very beginning, from question 1 again. But Vaganych remembers everything. The order of answers for each question and the order of questions remain unchanged, as well as the question and answers themselves.
Vaganych is very smart and his memory is superb, yet he is unbelievably unlucky and knows nothing whatsoever about the test's theme. How many clicks will he have to perform in the worst case?
Input
The first line contains a positive integer n (1 ≤ n ≤ 100). It is the number of questions in the test. The second line contains space-separated n positive integers ai (1 ≤ ai ≤ 109), the number of answer variants to question i.
Output
Print a single number — the minimal number of clicks needed to pass the test it the worst-case scenario.
Please do not use the %lld specificator to read or write 64-bit integers in С++. It is preferred to use the cin, cout streams or the %I64d specificator.
Examples
Input
2
1 1
Output
2
Input
2
2 2
Output
5
Input
1
10
Output
10
Note
Note to the second sample. In the worst-case scenario you will need five clicks:
* the first click selects the first variant to the first question, this answer turns out to be wrong.
* the second click selects the second variant to the first question, it proves correct and we move on to the second question;
* the third click selects the first variant to the second question, it is wrong and we go back to question 1;
* the fourth click selects the second variant to the first question, it proves as correct as it was and we move on to the second question;
* the fifth click selects the second variant to the second question, it proves correct, the test is finished.
Submitted Solution:
```
n=int(input())
p=input().split()
l=[]
i=0
while i<n:
l.append(int(p[i]))
i=i+1
s=l[0]
for i in range(1,n):
s=s+l[i]+i*(l[i]-1)
print(s)
``` | instruction | 0 | 39,626 | 11 | 79,252 |
Yes | output | 1 | 39,626 | 11 | 79,253 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
The average miner Vaganych took refresher courses. As soon as a miner completes the courses, he should take exams. The hardest one is a computer test called "Testing Pants for Sadness".
The test consists of n questions; the questions are to be answered strictly in the order in which they are given, from question 1 to question n. Question i contains ai answer variants, exactly one of them is correct.
A click is regarded as selecting any answer in any question. The goal is to select the correct answer for each of the n questions. If Vaganych selects a wrong answer for some question, then all selected answers become unselected and the test starts from the very beginning, from question 1 again. But Vaganych remembers everything. The order of answers for each question and the order of questions remain unchanged, as well as the question and answers themselves.
Vaganych is very smart and his memory is superb, yet he is unbelievably unlucky and knows nothing whatsoever about the test's theme. How many clicks will he have to perform in the worst case?
Input
The first line contains a positive integer n (1 ≤ n ≤ 100). It is the number of questions in the test. The second line contains space-separated n positive integers ai (1 ≤ ai ≤ 109), the number of answer variants to question i.
Output
Print a single number — the minimal number of clicks needed to pass the test it the worst-case scenario.
Please do not use the %lld specificator to read or write 64-bit integers in С++. It is preferred to use the cin, cout streams or the %I64d specificator.
Examples
Input
2
1 1
Output
2
Input
2
2 2
Output
5
Input
1
10
Output
10
Note
Note to the second sample. In the worst-case scenario you will need five clicks:
* the first click selects the first variant to the first question, this answer turns out to be wrong.
* the second click selects the second variant to the first question, it proves correct and we move on to the second question;
* the third click selects the first variant to the second question, it is wrong and we go back to question 1;
* the fourth click selects the second variant to the first question, it proves as correct as it was and we move on to the second question;
* the fifth click selects the second variant to the second question, it proves correct, the test is finished.
Submitted Solution:
```
n=int(input())
a=[int(x) for x in input().split()]
x=sum(a)
for i in range(1,n):
x+=(a[i]-1)*i
print(x)
``` | instruction | 0 | 39,627 | 11 | 79,254 |
Yes | output | 1 | 39,627 | 11 | 79,255 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
The average miner Vaganych took refresher courses. As soon as a miner completes the courses, he should take exams. The hardest one is a computer test called "Testing Pants for Sadness".
The test consists of n questions; the questions are to be answered strictly in the order in which they are given, from question 1 to question n. Question i contains ai answer variants, exactly one of them is correct.
A click is regarded as selecting any answer in any question. The goal is to select the correct answer for each of the n questions. If Vaganych selects a wrong answer for some question, then all selected answers become unselected and the test starts from the very beginning, from question 1 again. But Vaganych remembers everything. The order of answers for each question and the order of questions remain unchanged, as well as the question and answers themselves.
Vaganych is very smart and his memory is superb, yet he is unbelievably unlucky and knows nothing whatsoever about the test's theme. How many clicks will he have to perform in the worst case?
Input
The first line contains a positive integer n (1 ≤ n ≤ 100). It is the number of questions in the test. The second line contains space-separated n positive integers ai (1 ≤ ai ≤ 109), the number of answer variants to question i.
Output
Print a single number — the minimal number of clicks needed to pass the test it the worst-case scenario.
Please do not use the %lld specificator to read or write 64-bit integers in С++. It is preferred to use the cin, cout streams or the %I64d specificator.
Examples
Input
2
1 1
Output
2
Input
2
2 2
Output
5
Input
1
10
Output
10
Note
Note to the second sample. In the worst-case scenario you will need five clicks:
* the first click selects the first variant to the first question, this answer turns out to be wrong.
* the second click selects the second variant to the first question, it proves correct and we move on to the second question;
* the third click selects the first variant to the second question, it is wrong and we go back to question 1;
* the fourth click selects the second variant to the first question, it proves as correct as it was and we move on to the second question;
* the fifth click selects the second variant to the second question, it proves correct, the test is finished.
Submitted Solution:
```
n = int(input())
A = list(map(int, input().split()))
result = 0
for i in range(n):
result += A[i] * (i + 1)
print(result - n + 1)
``` | instruction | 0 | 39,628 | 11 | 79,256 |
No | output | 1 | 39,628 | 11 | 79,257 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
The average miner Vaganych took refresher courses. As soon as a miner completes the courses, he should take exams. The hardest one is a computer test called "Testing Pants for Sadness".
The test consists of n questions; the questions are to be answered strictly in the order in which they are given, from question 1 to question n. Question i contains ai answer variants, exactly one of them is correct.
A click is regarded as selecting any answer in any question. The goal is to select the correct answer for each of the n questions. If Vaganych selects a wrong answer for some question, then all selected answers become unselected and the test starts from the very beginning, from question 1 again. But Vaganych remembers everything. The order of answers for each question and the order of questions remain unchanged, as well as the question and answers themselves.
Vaganych is very smart and his memory is superb, yet he is unbelievably unlucky and knows nothing whatsoever about the test's theme. How many clicks will he have to perform in the worst case?
Input
The first line contains a positive integer n (1 ≤ n ≤ 100). It is the number of questions in the test. The second line contains space-separated n positive integers ai (1 ≤ ai ≤ 109), the number of answer variants to question i.
Output
Print a single number — the minimal number of clicks needed to pass the test it the worst-case scenario.
Please do not use the %lld specificator to read or write 64-bit integers in С++. It is preferred to use the cin, cout streams or the %I64d specificator.
Examples
Input
2
1 1
Output
2
Input
2
2 2
Output
5
Input
1
10
Output
10
Note
Note to the second sample. In the worst-case scenario you will need five clicks:
* the first click selects the first variant to the first question, this answer turns out to be wrong.
* the second click selects the second variant to the first question, it proves correct and we move on to the second question;
* the third click selects the first variant to the second question, it is wrong and we go back to question 1;
* the fourth click selects the second variant to the first question, it proves as correct as it was and we move on to the second question;
* the fifth click selects the second variant to the second question, it proves correct, the test is finished.
Submitted Solution:
```
n = int(input())
questions = [int(c) for c in input().split()]
ans = 0
for i, q in enumerate(questions):
if q == 1:
continue
ans += q - 1 + i
ans += len(questions)
print(ans)
``` | instruction | 0 | 39,629 | 11 | 79,258 |
No | output | 1 | 39,629 | 11 | 79,259 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
The average miner Vaganych took refresher courses. As soon as a miner completes the courses, he should take exams. The hardest one is a computer test called "Testing Pants for Sadness".
The test consists of n questions; the questions are to be answered strictly in the order in which they are given, from question 1 to question n. Question i contains ai answer variants, exactly one of them is correct.
A click is regarded as selecting any answer in any question. The goal is to select the correct answer for each of the n questions. If Vaganych selects a wrong answer for some question, then all selected answers become unselected and the test starts from the very beginning, from question 1 again. But Vaganych remembers everything. The order of answers for each question and the order of questions remain unchanged, as well as the question and answers themselves.
Vaganych is very smart and his memory is superb, yet he is unbelievably unlucky and knows nothing whatsoever about the test's theme. How many clicks will he have to perform in the worst case?
Input
The first line contains a positive integer n (1 ≤ n ≤ 100). It is the number of questions in the test. The second line contains space-separated n positive integers ai (1 ≤ ai ≤ 109), the number of answer variants to question i.
Output
Print a single number — the minimal number of clicks needed to pass the test it the worst-case scenario.
Please do not use the %lld specificator to read or write 64-bit integers in С++. It is preferred to use the cin, cout streams or the %I64d specificator.
Examples
Input
2
1 1
Output
2
Input
2
2 2
Output
5
Input
1
10
Output
10
Note
Note to the second sample. In the worst-case scenario you will need five clicks:
* the first click selects the first variant to the first question, this answer turns out to be wrong.
* the second click selects the second variant to the first question, it proves correct and we move on to the second question;
* the third click selects the first variant to the second question, it is wrong and we go back to question 1;
* the fourth click selects the second variant to the first question, it proves as correct as it was and we move on to the second question;
* the fifth click selects the second variant to the second question, it proves correct, the test is finished.
Submitted Solution:
```
n = int(input())
questions = [int(c) for c in input().split()]
ans = 0
for i in range(0, n-1):
ans += questions[i] - 1 + questions[i+1]
ans += questions[-1]
print(ans)
``` | instruction | 0 | 39,630 | 11 | 79,260 |
No | output | 1 | 39,630 | 11 | 79,261 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
The average miner Vaganych took refresher courses. As soon as a miner completes the courses, he should take exams. The hardest one is a computer test called "Testing Pants for Sadness".
The test consists of n questions; the questions are to be answered strictly in the order in which they are given, from question 1 to question n. Question i contains ai answer variants, exactly one of them is correct.
A click is regarded as selecting any answer in any question. The goal is to select the correct answer for each of the n questions. If Vaganych selects a wrong answer for some question, then all selected answers become unselected and the test starts from the very beginning, from question 1 again. But Vaganych remembers everything. The order of answers for each question and the order of questions remain unchanged, as well as the question and answers themselves.
Vaganych is very smart and his memory is superb, yet he is unbelievably unlucky and knows nothing whatsoever about the test's theme. How many clicks will he have to perform in the worst case?
Input
The first line contains a positive integer n (1 ≤ n ≤ 100). It is the number of questions in the test. The second line contains space-separated n positive integers ai (1 ≤ ai ≤ 109), the number of answer variants to question i.
Output
Print a single number — the minimal number of clicks needed to pass the test it the worst-case scenario.
Please do not use the %lld specificator to read or write 64-bit integers in С++. It is preferred to use the cin, cout streams or the %I64d specificator.
Examples
Input
2
1 1
Output
2
Input
2
2 2
Output
5
Input
1
10
Output
10
Note
Note to the second sample. In the worst-case scenario you will need five clicks:
* the first click selects the first variant to the first question, this answer turns out to be wrong.
* the second click selects the second variant to the first question, it proves correct and we move on to the second question;
* the third click selects the first variant to the second question, it is wrong and we go back to question 1;
* the fourth click selects the second variant to the first question, it proves as correct as it was and we move on to the second question;
* the fifth click selects the second variant to the second question, it proves correct, the test is finished.
Submitted Solution:
```
n = int(input())
questions = [int(c) for c in input().split()]
ans = 0
for i, q in enumerate(questions):
ans += q - 1 + i
ans += len(questions)
print(ans)
``` | instruction | 0 | 39,631 | 11 | 79,262 |
No | output | 1 | 39,631 | 11 | 79,263 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
Numbers 1, 2, 3, ... n (each integer from 1 to n once) are written on a board. In one operation you can erase any two numbers a and b from the board and write one integer (a + b)/(2) rounded up instead.
You should perform the given operation n - 1 times and make the resulting number that will be left on the board as small as possible.
For example, if n = 4, the following course of action is optimal:
1. choose a = 4 and b = 2, so the new number is 3, and the whiteboard contains [1, 3, 3];
2. choose a = 3 and b = 3, so the new number is 3, and the whiteboard contains [1, 3];
3. choose a = 1 and b = 3, so the new number is 2, and the whiteboard contains [2].
It's easy to see that after n - 1 operations, there will be left only one number. Your goal is to minimize it.
Input
The first line contains one integer t (1 ≤ t ≤ 1000) — the number of test cases.
The only line of each test case contains one integer n (2 ≤ n ≤ 2 ⋅ 10^5) — the number of integers written on the board initially.
It's guaranteed that the total sum of n over test cases doesn't exceed 2 ⋅ 10^5.
Output
For each test case, in the first line, print the minimum possible number left on the board after n - 1 operations. Each of the next n - 1 lines should contain two integers — numbers a and b chosen and erased in each operation.
Example
Input
1
4
Output
2
2 4
3 3
3 1
Submitted Solution:
```
for _ in range(int(input())):
n=int(input())
print(2)
if n==2:
print(2,1)
else:
print(n,n-2)
print(n-1,n-1)
for i in range(n-3):
print(n-1-i,n-3-i)
``` | instruction | 0 | 39,810 | 11 | 79,620 |
Yes | output | 1 | 39,810 | 11 | 79,621 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
Numbers 1, 2, 3, ... n (each integer from 1 to n once) are written on a board. In one operation you can erase any two numbers a and b from the board and write one integer (a + b)/(2) rounded up instead.
You should perform the given operation n - 1 times and make the resulting number that will be left on the board as small as possible.
For example, if n = 4, the following course of action is optimal:
1. choose a = 4 and b = 2, so the new number is 3, and the whiteboard contains [1, 3, 3];
2. choose a = 3 and b = 3, so the new number is 3, and the whiteboard contains [1, 3];
3. choose a = 1 and b = 3, so the new number is 2, and the whiteboard contains [2].
It's easy to see that after n - 1 operations, there will be left only one number. Your goal is to minimize it.
Input
The first line contains one integer t (1 ≤ t ≤ 1000) — the number of test cases.
The only line of each test case contains one integer n (2 ≤ n ≤ 2 ⋅ 10^5) — the number of integers written on the board initially.
It's guaranteed that the total sum of n over test cases doesn't exceed 2 ⋅ 10^5.
Output
For each test case, in the first line, print the minimum possible number left on the board after n - 1 operations. Each of the next n - 1 lines should contain two integers — numbers a and b chosen and erased in each operation.
Example
Input
1
4
Output
2
2 4
3 3
3 1
Submitted Solution:
```
# Problem: C. Numbers on Whiteboard
# Contest: Codeforces - Educational Codeforces Round 96 (Rated for Div. 2)
# URL: https://codeforces.com/contest/1430/problem/C
# Memory Limit: 256 MB
# Time Limit: 2000 ms
#
# Powered by CP Editor (https://cpeditor.org)
from heapq import heapify,heappop,heappush
for _ in range(int(input())):
n=int(input())
A=[-1*int(_) for _ in range(1,n+1)]
heapify(A)
X=[]
for _ in range(n-1):
x=heappop(A)*-1
y=heappop(A)*-1
X.append([x,y])
heappush(A,-1*((x+y+1)//2))
print(heappop(A)*-1)
for _ in X:
print(*_)
``` | instruction | 0 | 39,811 | 11 | 79,622 |
Yes | output | 1 | 39,811 | 11 | 79,623 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
Numbers 1, 2, 3, ... n (each integer from 1 to n once) are written on a board. In one operation you can erase any two numbers a and b from the board and write one integer (a + b)/(2) rounded up instead.
You should perform the given operation n - 1 times and make the resulting number that will be left on the board as small as possible.
For example, if n = 4, the following course of action is optimal:
1. choose a = 4 and b = 2, so the new number is 3, and the whiteboard contains [1, 3, 3];
2. choose a = 3 and b = 3, so the new number is 3, and the whiteboard contains [1, 3];
3. choose a = 1 and b = 3, so the new number is 2, and the whiteboard contains [2].
It's easy to see that after n - 1 operations, there will be left only one number. Your goal is to minimize it.
Input
The first line contains one integer t (1 ≤ t ≤ 1000) — the number of test cases.
The only line of each test case contains one integer n (2 ≤ n ≤ 2 ⋅ 10^5) — the number of integers written on the board initially.
It's guaranteed that the total sum of n over test cases doesn't exceed 2 ⋅ 10^5.
Output
For each test case, in the first line, print the minimum possible number left on the board after n - 1 operations. Each of the next n - 1 lines should contain two integers — numbers a and b chosen and erased in each operation.
Example
Input
1
4
Output
2
2 4
3 3
3 1
Submitted Solution:
```
test = int(input())
for _ in range(test):
n = int(input())
if(n == 2):
print(2)
print(1,2)
elif(n ==3):
print(2)
print(2,3)
print(1,3)
else:
print(2)
print(n-1,n)
print(n-2,n)
j = 1
for i in range(n-3,0,-1):
print(i,n-j)
j += 1
``` | instruction | 0 | 39,812 | 11 | 79,624 |
Yes | output | 1 | 39,812 | 11 | 79,625 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
Numbers 1, 2, 3, ... n (each integer from 1 to n once) are written on a board. In one operation you can erase any two numbers a and b from the board and write one integer (a + b)/(2) rounded up instead.
You should perform the given operation n - 1 times and make the resulting number that will be left on the board as small as possible.
For example, if n = 4, the following course of action is optimal:
1. choose a = 4 and b = 2, so the new number is 3, and the whiteboard contains [1, 3, 3];
2. choose a = 3 and b = 3, so the new number is 3, and the whiteboard contains [1, 3];
3. choose a = 1 and b = 3, so the new number is 2, and the whiteboard contains [2].
It's easy to see that after n - 1 operations, there will be left only one number. Your goal is to minimize it.
Input
The first line contains one integer t (1 ≤ t ≤ 1000) — the number of test cases.
The only line of each test case contains one integer n (2 ≤ n ≤ 2 ⋅ 10^5) — the number of integers written on the board initially.
It's guaranteed that the total sum of n over test cases doesn't exceed 2 ⋅ 10^5.
Output
For each test case, in the first line, print the minimum possible number left on the board after n - 1 operations. Each of the next n - 1 lines should contain two integers — numbers a and b chosen and erased in each operation.
Example
Input
1
4
Output
2
2 4
3 3
3 1
Submitted Solution:
```
from math import ceil
for _ in range(int(input())):
n=int(input())
o=[0];e=[0]
for i in range(1,n+1):
if i%2==0:
e.append(i)
else:
o.append(i)
l=[]
while (len(e)>=1 and len(o)>2) or (len(e)>2 and len(o)>=1):
if e[-1]>o[-1]:
x,y=e.pop(),e.pop()
l.append([x,y])
x=(x+y)//2
if x%2:
o.append(x)
else:
e.append(x)
else:
x,y=o.pop(),o.pop()
l.append([x,y])
x=(x+y)//2
if x%2:
o.append(x)
else:
e.append(x)
if len(e)==2 and len(o)==2:
x,y=e.pop(),o.pop()
l.append([x,y])
e.append(ceil((x+y)/2))
if len(o)>1:
print(o[-1])
else:
print(e[-1])
for i,j in l:
print(i,j)
``` | instruction | 0 | 39,813 | 11 | 79,626 |
Yes | output | 1 | 39,813 | 11 | 79,627 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
Numbers 1, 2, 3, ... n (each integer from 1 to n once) are written on a board. In one operation you can erase any two numbers a and b from the board and write one integer (a + b)/(2) rounded up instead.
You should perform the given operation n - 1 times and make the resulting number that will be left on the board as small as possible.
For example, if n = 4, the following course of action is optimal:
1. choose a = 4 and b = 2, so the new number is 3, and the whiteboard contains [1, 3, 3];
2. choose a = 3 and b = 3, so the new number is 3, and the whiteboard contains [1, 3];
3. choose a = 1 and b = 3, so the new number is 2, and the whiteboard contains [2].
It's easy to see that after n - 1 operations, there will be left only one number. Your goal is to minimize it.
Input
The first line contains one integer t (1 ≤ t ≤ 1000) — the number of test cases.
The only line of each test case contains one integer n (2 ≤ n ≤ 2 ⋅ 10^5) — the number of integers written on the board initially.
It's guaranteed that the total sum of n over test cases doesn't exceed 2 ⋅ 10^5.
Output
For each test case, in the first line, print the minimum possible number left on the board after n - 1 operations. Each of the next n - 1 lines should contain two integers — numbers a and b chosen and erased in each operation.
Example
Input
1
4
Output
2
2 4
3 3
3 1
Submitted Solution:
```
for _ in range(int(input())):
a=0
l=[]
n=int(input())
lenl=n
for i in range(n,1,-1):
if a==0:
l+=[n-2,n]
n-=1
else:
l+=[n,n]
a=1-a
print(2)
for i in range(0,2*(lenl-1),2):
print(l[i],l[i+1])
``` | instruction | 0 | 39,816 | 11 | 79,632 |
No | output | 1 | 39,816 | 11 | 79,633 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
Valera loves to participate in competitions. Especially in programming contests. Today he has participated in the contest with his team, consisting of n students (including Valera). This contest was an individual competition, so each student in the team solved problems individually.
After the contest was over, Valera was interested in results. He found out that:
* each student in the team scored at least l points and at most r points;
* in total, all members of the team scored exactly sall points;
* the total score of the k members of the team who scored the most points is equal to exactly sk; more formally, if a1, a2, ..., an is the sequence of points earned by the team of students in the non-increasing order (a1 ≥ a2 ≥ ... ≥ an), then sk = a1 + a2 + ... + ak.
However, Valera did not find out exactly how many points each of n students scored. Valera asked you to recover any distribution of scores between the students of the team, such that all the conditions above are met.
Input
The first line of the input contains exactly six integers n, k, l, r, sall, sk (1 ≤ n, k, l, r ≤ 1000; l ≤ r; k ≤ n; 1 ≤ sk ≤ sall ≤ 106).
It's guaranteed that the input is such that the answer exists.
Output
Print exactly n integers a1, a2, ..., an — the number of points each student scored. If there are multiple solutions, you can print any of them. You can print the distribution of points in any order.
Examples
Input
5 3 1 3 13 9
Output
2 3 2 3 3
Input
5 3 1 3 15 9
Output
3 3 3 3 3
Submitted Solution:
```
def f(n, m):
if not n:
return []
b = [m // n] * n
for i in range(m % n):
b[i] += 1
return b
a = list(map(int, input().split()))
print (*(f(a[1], a[5]) + f(a[0] - a[1], a[4] - a[5])))
``` | instruction | 0 | 39,930 | 11 | 79,860 |
Yes | output | 1 | 39,930 | 11 | 79,861 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
Valera loves to participate in competitions. Especially in programming contests. Today he has participated in the contest with his team, consisting of n students (including Valera). This contest was an individual competition, so each student in the team solved problems individually.
After the contest was over, Valera was interested in results. He found out that:
* each student in the team scored at least l points and at most r points;
* in total, all members of the team scored exactly sall points;
* the total score of the k members of the team who scored the most points is equal to exactly sk; more formally, if a1, a2, ..., an is the sequence of points earned by the team of students in the non-increasing order (a1 ≥ a2 ≥ ... ≥ an), then sk = a1 + a2 + ... + ak.
However, Valera did not find out exactly how many points each of n students scored. Valera asked you to recover any distribution of scores between the students of the team, such that all the conditions above are met.
Input
The first line of the input contains exactly six integers n, k, l, r, sall, sk (1 ≤ n, k, l, r ≤ 1000; l ≤ r; k ≤ n; 1 ≤ sk ≤ sall ≤ 106).
It's guaranteed that the input is such that the answer exists.
Output
Print exactly n integers a1, a2, ..., an — the number of points each student scored. If there are multiple solutions, you can print any of them. You can print the distribution of points in any order.
Examples
Input
5 3 1 3 13 9
Output
2 3 2 3 3
Input
5 3 1 3 15 9
Output
3 3 3 3 3
Submitted Solution:
```
n,k,l,r,tot,ktot=map(int,input().split())
ans=[0]*n
ind=ktot//k
extra=ktot%k
for i in range(k):
ans[i]=ind
for i in range(extra):
ans[i]+=1
if n==k:
print(*ans)
exit()
index=k
rem=tot-ktot
remp=n-k
givmini=rem//remp
from math import ceil
givmaxi=ceil(rem/remp)
remainder=rem%remp
getmini=remp-remainder
getmaxi=remainder
for i in range(getmini):
ans[k]=givmini
k+=1
for i in range(getmaxi):
ans[k]=givmaxi
k+=1
print(*ans)
``` | instruction | 0 | 39,931 | 11 | 79,862 |
Yes | output | 1 | 39,931 | 11 | 79,863 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
Valera loves to participate in competitions. Especially in programming contests. Today he has participated in the contest with his team, consisting of n students (including Valera). This contest was an individual competition, so each student in the team solved problems individually.
After the contest was over, Valera was interested in results. He found out that:
* each student in the team scored at least l points and at most r points;
* in total, all members of the team scored exactly sall points;
* the total score of the k members of the team who scored the most points is equal to exactly sk; more formally, if a1, a2, ..., an is the sequence of points earned by the team of students in the non-increasing order (a1 ≥ a2 ≥ ... ≥ an), then sk = a1 + a2 + ... + ak.
However, Valera did not find out exactly how many points each of n students scored. Valera asked you to recover any distribution of scores between the students of the team, such that all the conditions above are met.
Input
The first line of the input contains exactly six integers n, k, l, r, sall, sk (1 ≤ n, k, l, r ≤ 1000; l ≤ r; k ≤ n; 1 ≤ sk ≤ sall ≤ 106).
It's guaranteed that the input is such that the answer exists.
Output
Print exactly n integers a1, a2, ..., an — the number of points each student scored. If there are multiple solutions, you can print any of them. You can print the distribution of points in any order.
Examples
Input
5 3 1 3 13 9
Output
2 3 2 3 3
Input
5 3 1 3 15 9
Output
3 3 3 3 3
Submitted Solution:
```
n,k,l,r,sn,sk = map(int,input().split())
sk2 = sn - sk
temp = 0
temp2 = 0
for num in range(l,r+1):
if sk >= num * k and (num+1) * k > sk:
temp = sk - num*k
temp2 = num
print((str(num+1)+" ")*temp,end="")
print((str(num)+" ")*(k-temp),end="")
break
k2 = n - k
for num in range(l,temp2+1):
if sk2 >= num * k2 and (num+1) * k2 > sk2:
temp = sk2 - num*k2
print((str(num+1)+" ")*temp,end="")
print((str(num)+" ")*(k2-temp),end="")
break
``` | instruction | 0 | 39,932 | 11 | 79,864 |
Yes | output | 1 | 39,932 | 11 | 79,865 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
Valera loves to participate in competitions. Especially in programming contests. Today he has participated in the contest with his team, consisting of n students (including Valera). This contest was an individual competition, so each student in the team solved problems individually.
After the contest was over, Valera was interested in results. He found out that:
* each student in the team scored at least l points and at most r points;
* in total, all members of the team scored exactly sall points;
* the total score of the k members of the team who scored the most points is equal to exactly sk; more formally, if a1, a2, ..., an is the sequence of points earned by the team of students in the non-increasing order (a1 ≥ a2 ≥ ... ≥ an), then sk = a1 + a2 + ... + ak.
However, Valera did not find out exactly how many points each of n students scored. Valera asked you to recover any distribution of scores between the students of the team, such that all the conditions above are met.
Input
The first line of the input contains exactly six integers n, k, l, r, sall, sk (1 ≤ n, k, l, r ≤ 1000; l ≤ r; k ≤ n; 1 ≤ sk ≤ sall ≤ 106).
It's guaranteed that the input is such that the answer exists.
Output
Print exactly n integers a1, a2, ..., an — the number of points each student scored. If there are multiple solutions, you can print any of them. You can print the distribution of points in any order.
Examples
Input
5 3 1 3 13 9
Output
2 3 2 3 3
Input
5 3 1 3 15 9
Output
3 3 3 3 3
Submitted Solution:
```
import math
n,k,l,r,sall,sk = map(int,input().split())
osk,ok = sk,k
ans = []
while k:
x = math.ceil(sk/k)
ans.append(x)
k -= 1
sk -= x
v = n-ok
sall -= osk
while v:
x = math.ceil(sall/v)
ans.append(x)
v -= 1
sall -= x
print(*ans)
``` | instruction | 0 | 39,933 | 11 | 79,866 |
Yes | output | 1 | 39,933 | 11 | 79,867 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
Valera loves to participate in competitions. Especially in programming contests. Today he has participated in the contest with his team, consisting of n students (including Valera). This contest was an individual competition, so each student in the team solved problems individually.
After the contest was over, Valera was interested in results. He found out that:
* each student in the team scored at least l points and at most r points;
* in total, all members of the team scored exactly sall points;
* the total score of the k members of the team who scored the most points is equal to exactly sk; more formally, if a1, a2, ..., an is the sequence of points earned by the team of students in the non-increasing order (a1 ≥ a2 ≥ ... ≥ an), then sk = a1 + a2 + ... + ak.
However, Valera did not find out exactly how many points each of n students scored. Valera asked you to recover any distribution of scores between the students of the team, such that all the conditions above are met.
Input
The first line of the input contains exactly six integers n, k, l, r, sall, sk (1 ≤ n, k, l, r ≤ 1000; l ≤ r; k ≤ n; 1 ≤ sk ≤ sall ≤ 106).
It's guaranteed that the input is such that the answer exists.
Output
Print exactly n integers a1, a2, ..., an — the number of points each student scored. If there are multiple solutions, you can print any of them. You can print the distribution of points in any order.
Examples
Input
5 3 1 3 13 9
Output
2 3 2 3 3
Input
5 3 1 3 15 9
Output
3 3 3 3 3
Submitted Solution:
```
n, k, l, r, s_n, s_k = map(int, input().split())
a = [l for i in range(n)]
div = (s_k - k*l)//k
rem = (s_k - k*l)%k
# print(div, rem)
for i in range(k):
a[i] += div
i = 0
while rem > 0 and i < k:
a[i] += min(rem, r-a[i])
rem -= min(rem, r-a[i])
i += 1
div = (s_n - s_k - (n-k)*l)//(n-k)
rem = (s_n - s_k - (n-k)*l)%(n-k)
# print(div, rem)
for i in range(k, n):
a[i] += div
i = k
while rem > 0 and i < n:
a[i] += min(rem, a[k-1]-a[i])
rem -= min(rem, a[k-1]-a[i])
i += 1
for i in range(n):
print(a[i], end = " ")
print()
``` | instruction | 0 | 39,934 | 11 | 79,868 |
No | output | 1 | 39,934 | 11 | 79,869 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
Valera loves to participate in competitions. Especially in programming contests. Today he has participated in the contest with his team, consisting of n students (including Valera). This contest was an individual competition, so each student in the team solved problems individually.
After the contest was over, Valera was interested in results. He found out that:
* each student in the team scored at least l points and at most r points;
* in total, all members of the team scored exactly sall points;
* the total score of the k members of the team who scored the most points is equal to exactly sk; more formally, if a1, a2, ..., an is the sequence of points earned by the team of students in the non-increasing order (a1 ≥ a2 ≥ ... ≥ an), then sk = a1 + a2 + ... + ak.
However, Valera did not find out exactly how many points each of n students scored. Valera asked you to recover any distribution of scores between the students of the team, such that all the conditions above are met.
Input
The first line of the input contains exactly six integers n, k, l, r, sall, sk (1 ≤ n, k, l, r ≤ 1000; l ≤ r; k ≤ n; 1 ≤ sk ≤ sall ≤ 106).
It's guaranteed that the input is such that the answer exists.
Output
Print exactly n integers a1, a2, ..., an — the number of points each student scored. If there are multiple solutions, you can print any of them. You can print the distribution of points in any order.
Examples
Input
5 3 1 3 13 9
Output
2 3 2 3 3
Input
5 3 1 3 15 9
Output
3 3 3 3 3
Submitted Solution:
```
import sys
import string
from collections import defaultdict
from functools import lru_cache
from collections import Counter
def mi(s):
return map(int, s.strip().split())
def lmi(s):
return list(mi(s))
def mf(f, s):
return map(f, s)
def lmf(f, s):
return list(mf(f, s))
def main(n, k, l, r, sa, sk):
ans = [0 for _ in range(n)]
first_sum = sa - sk
if k < n:
pos, rem = first_sum // (n - k), first_sum % (n - k)
m_val = pos
for i in range(n - k):
ans[i] = pos
for i in range(rem):
ans[i] += 1
m_val = pos + 1
for i in range(n - k, n):
ans[i] = m_val
else:
m_val = 0
rem = sk - k * m_val
i = n - k
while rem > 0:
to_add = min(rem, r - m_val)
ans[i] += to_add
rem -= to_add
i += 1
print(" ".join(str(d) for d in ans))
if __name__ == "__main__":
for e, line in enumerate(sys.stdin.readlines()):
main(*mi(line))
``` | instruction | 0 | 39,935 | 11 | 79,870 |
No | output | 1 | 39,935 | 11 | 79,871 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
Valera loves to participate in competitions. Especially in programming contests. Today he has participated in the contest with his team, consisting of n students (including Valera). This contest was an individual competition, so each student in the team solved problems individually.
After the contest was over, Valera was interested in results. He found out that:
* each student in the team scored at least l points and at most r points;
* in total, all members of the team scored exactly sall points;
* the total score of the k members of the team who scored the most points is equal to exactly sk; more formally, if a1, a2, ..., an is the sequence of points earned by the team of students in the non-increasing order (a1 ≥ a2 ≥ ... ≥ an), then sk = a1 + a2 + ... + ak.
However, Valera did not find out exactly how many points each of n students scored. Valera asked you to recover any distribution of scores between the students of the team, such that all the conditions above are met.
Input
The first line of the input contains exactly six integers n, k, l, r, sall, sk (1 ≤ n, k, l, r ≤ 1000; l ≤ r; k ≤ n; 1 ≤ sk ≤ sall ≤ 106).
It's guaranteed that the input is such that the answer exists.
Output
Print exactly n integers a1, a2, ..., an — the number of points each student scored. If there are multiple solutions, you can print any of them. You can print the distribution of points in any order.
Examples
Input
5 3 1 3 13 9
Output
2 3 2 3 3
Input
5 3 1 3 15 9
Output
3 3 3 3 3
Submitted Solution:
```
a,b,c,d,e,f=map(int,input().split())
x=f//b
r=[]
for i in range(b):
r.append(str(x))
e-=f
a-=b
y=e//a
for i in range(a):
r.append(str(y))
print(''.join(r))
``` | instruction | 0 | 39,936 | 11 | 79,872 |
No | output | 1 | 39,936 | 11 | 79,873 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
Valera loves to participate in competitions. Especially in programming contests. Today he has participated in the contest with his team, consisting of n students (including Valera). This contest was an individual competition, so each student in the team solved problems individually.
After the contest was over, Valera was interested in results. He found out that:
* each student in the team scored at least l points and at most r points;
* in total, all members of the team scored exactly sall points;
* the total score of the k members of the team who scored the most points is equal to exactly sk; more formally, if a1, a2, ..., an is the sequence of points earned by the team of students in the non-increasing order (a1 ≥ a2 ≥ ... ≥ an), then sk = a1 + a2 + ... + ak.
However, Valera did not find out exactly how many points each of n students scored. Valera asked you to recover any distribution of scores between the students of the team, such that all the conditions above are met.
Input
The first line of the input contains exactly six integers n, k, l, r, sall, sk (1 ≤ n, k, l, r ≤ 1000; l ≤ r; k ≤ n; 1 ≤ sk ≤ sall ≤ 106).
It's guaranteed that the input is such that the answer exists.
Output
Print exactly n integers a1, a2, ..., an — the number of points each student scored. If there are multiple solutions, you can print any of them. You can print the distribution of points in any order.
Examples
Input
5 3 1 3 13 9
Output
2 3 2 3 3
Input
5 3 1 3 15 9
Output
3 3 3 3 3
Submitted Solution:
```
n,k,l,r,sa,s=map(int,input().split())
out=[]
x=sa-s
for i in range(k-1):
out.append(l)
sum_out=sum(out)
net=s-sum_out
out.append(net)
sum_out=0
for i in range(n-k-1):
out.append(l)
sum_out+=l
net=x-sum_out
out.append(net)
print(' '.join(map(str,out)))
``` | instruction | 0 | 39,937 | 11 | 79,874 |
No | output | 1 | 39,937 | 11 | 79,875 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
Toastman came up with a very easy task. He gives it to Appleman, but Appleman doesn't know how to solve it. Can you help him?
Given a n × n checkerboard. Each cell of the board has either character 'x', or character 'o'. Is it true that each cell of the board has even number of adjacent cells with 'o'? Two cells of the board are adjacent if they share a side.
Input
The first line contains an integer n (1 ≤ n ≤ 100). Then n lines follow containing the description of the checkerboard. Each of them contains n characters (either 'x' or 'o') without spaces.
Output
Print "YES" or "NO" (without the quotes) depending on the answer to the problem.
Examples
Input
3
xxo
xox
oxx
Output
YES
Input
4
xxxo
xoxo
oxox
xxxx
Output
NO
Submitted Solution:
```
res = 'YES'
n = int(input())
board = [None]*n
for i in range(n):
board[i] = input()
for i in range(n):
for j in range(n):
adj_o_cells_num = 0
candidates = []
for candidate in ([i-1, j], [i+1, j], [i, j-1], [i, j+1]):
if candidate[0] >= 0 and candidate[0] < n and candidate[1] >= 0 and candidate[1] < n:
candidates.append(candidate)
for candidate in candidates:
if board[candidate[0]][candidate[1]] == 'o':
adj_o_cells_num += 1
if adj_o_cells_num % 2:
res = 'NO'
break
if res == 'NO':
break
print(res)
``` | instruction | 0 | 39,976 | 11 | 79,952 |
Yes | output | 1 | 39,976 | 11 | 79,953 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
Example
Input
6
2
3
1
1
4
2
Output
Yes
Yes
Yes
No
Yes
No
Submitted Solution:
```
n = int(input())
bits = set()
count = 0
ans = []
for i in range(n):
x = int(input())
if x in bits:
y = x
while y in bits:
y -= 1
if y == 0 and count != x:
ans.append("No")
else:
bits.add(y)
if y == 0:
ans.append("No\n"*(n-i-1))
ans.append("No")
break
count += 1
for i in range(y+1, x+1):
bits.remove(i)
count -= 1
ans.append("Yes")
else:
bits.add(x)
count += 1
ans.append("Yes")
print("\n".join(ans))
``` | instruction | 0 | 41,145 | 11 | 82,290 |
No | output | 1 | 41,145 | 11 | 82,291 |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.