message stringlengths 2 45.8k | message_type stringclasses 2 values | message_id int64 0 1 | conversation_id int64 254 108k | cluster float64 3 3 | __index_level_0__ int64 508 217k |
|---|---|---|---|---|---|
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
It is Bubble Cup finals season and farmer Johnny Bubbles must harvest his bubbles. The bubbles are in a rectangular bubblefield formed of N x M square parcels divided into N rows and M columns. The parcel in i^{th} row and j^{th} column yields A_{i,j} bubbles.
Johnny Bubbles has available a very special self-driving bubble harvester that, once manually positioned at the beginning of a row or column, automatically harvests all the bubbles in that row or column. Once the harvester reaches the end of the row or column it stops and must be repositioned. The harvester can pass through any parcel any number of times, but it can collect bubbles from the parcel only once.
Johnny is very busy farmer, so he is available to manually position the harvester at most four times per day. Johnny is also impatient, so he wants to harvest as many bubbles as possible on the first day.
Please help Johnny to calculate what is the maximum number of bubbles he can collect on the first day.
Input
The first line contains two integers N and M (1 ≤ N, M ≤ N * M ≤ 10^{5}) - the bubblefield size.
Each of the next N lines contains M integers. The j^{th} element in the i^{th} line is A_{i,j} (0 ≤ a_{i,j} ≤ 10^{9}) — the yield of the parcel located in the i^{th} row and the j^{th} column.
Output
Output contains one integer number - maximum number of the bubbles Johnny can harvest on the first day.
Examples
Input
2 2
1 2
3 4
Output
10
Input
5 5
0 9 2 7 0
9 0 3 0 5
0 8 0 3 1
6 7 4 3 9
3 6 4 1 0
Output
80
Note
In the first example, farmer Johnny can harvest all the bubbles by positioning the harvester on the first and the second row.
In the second example, one way Johnny can harvest maximum number of bubbles is to position the harvester in the second row, the fourth row, the second column and the fourth column.
Submitted Solution:
```
def maxi_pos(vect: list):
pos_max, val_max = 0, 0
for i in range(len(vect)):
if vect[i] > val_max:
val_max = vect[i]
pos_max = i
return pos_max, val_max
N, M = map(int, input().split())
matrix = []
rows_sum = []
cols_sum = [0] * M
for i in range(N):
row = list(map(int, input().split()))
matrix.append(row)
rows_sum.append(sum(row))
for j in range(M):
cols_sum[j] += row[j]
result = 0
for i in range(4):
row_i, row_v = maxi_pos(rows_sum)
col_i, col_v = maxi_pos(cols_sum)
if row_v > col_v:
result += row_v
rows_sum[row_i] =0
for j in range(M):
cols_sum[j] -= matrix[row_i][j]
matrix[row_i][j] = 0
else:
result += col_v
cols_sum[col_i] = 0
for j in range(N):
rows_sum[j] -= matrix[j][col_i]
matrix[j][col_i] = 0
print(result)
``` | instruction | 0 | 16,042 | 3 | 32,084 |
No | output | 1 | 16,042 | 3 | 32,085 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
It is Bubble Cup finals season and farmer Johnny Bubbles must harvest his bubbles. The bubbles are in a rectangular bubblefield formed of N x M square parcels divided into N rows and M columns. The parcel in i^{th} row and j^{th} column yields A_{i,j} bubbles.
Johnny Bubbles has available a very special self-driving bubble harvester that, once manually positioned at the beginning of a row or column, automatically harvests all the bubbles in that row or column. Once the harvester reaches the end of the row or column it stops and must be repositioned. The harvester can pass through any parcel any number of times, but it can collect bubbles from the parcel only once.
Johnny is very busy farmer, so he is available to manually position the harvester at most four times per day. Johnny is also impatient, so he wants to harvest as many bubbles as possible on the first day.
Please help Johnny to calculate what is the maximum number of bubbles he can collect on the first day.
Input
The first line contains two integers N and M (1 ≤ N, M ≤ N * M ≤ 10^{5}) - the bubblefield size.
Each of the next N lines contains M integers. The j^{th} element in the i^{th} line is A_{i,j} (0 ≤ a_{i,j} ≤ 10^{9}) — the yield of the parcel located in the i^{th} row and the j^{th} column.
Output
Output contains one integer number - maximum number of the bubbles Johnny can harvest on the first day.
Examples
Input
2 2
1 2
3 4
Output
10
Input
5 5
0 9 2 7 0
9 0 3 0 5
0 8 0 3 1
6 7 4 3 9
3 6 4 1 0
Output
80
Note
In the first example, farmer Johnny can harvest all the bubbles by positioning the harvester on the first and the second row.
In the second example, one way Johnny can harvest maximum number of bubbles is to position the harvester in the second row, the fourth row, the second column and the fourth column.
Submitted Solution:
```
[N, M] = map(int, input().split())
grid = []
for _ in range(N):
grid.append([int(x) for x in input().split()])
def find_out(grid):
rows = []
for i in range(N):
rows.append((i, sum(grid[i])))
cols = []
for i in range(M):
s = 0
for j in range(N):
s = s + grid[j][i]
cols.append((i, s))
rows.sort(key = lambda x: x[1])
cols.sort(key = lambda x: x[1])
if (rows[-1][1] < cols[-1][1]):
return ('col', cols[-1])
else:
return ('row', rows[-1])
score = 0
for _ in range(4):
(sc, (idx, count)) = find_out(grid)
score = score + count
if sc == 'row':
for i in range(N):
grid[idx][i] = 0
else:
for i in range(M):
grid[i][idx] = 0
print(score)
``` | instruction | 0 | 16,043 | 3 | 32,086 |
No | output | 1 | 16,043 | 3 | 32,087 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
It is Bubble Cup finals season and farmer Johnny Bubbles must harvest his bubbles. The bubbles are in a rectangular bubblefield formed of N x M square parcels divided into N rows and M columns. The parcel in i^{th} row and j^{th} column yields A_{i,j} bubbles.
Johnny Bubbles has available a very special self-driving bubble harvester that, once manually positioned at the beginning of a row or column, automatically harvests all the bubbles in that row or column. Once the harvester reaches the end of the row or column it stops and must be repositioned. The harvester can pass through any parcel any number of times, but it can collect bubbles from the parcel only once.
Johnny is very busy farmer, so he is available to manually position the harvester at most four times per day. Johnny is also impatient, so he wants to harvest as many bubbles as possible on the first day.
Please help Johnny to calculate what is the maximum number of bubbles he can collect on the first day.
Input
The first line contains two integers N and M (1 ≤ N, M ≤ N * M ≤ 10^{5}) - the bubblefield size.
Each of the next N lines contains M integers. The j^{th} element in the i^{th} line is A_{i,j} (0 ≤ a_{i,j} ≤ 10^{9}) — the yield of the parcel located in the i^{th} row and the j^{th} column.
Output
Output contains one integer number - maximum number of the bubbles Johnny can harvest on the first day.
Examples
Input
2 2
1 2
3 4
Output
10
Input
5 5
0 9 2 7 0
9 0 3 0 5
0 8 0 3 1
6 7 4 3 9
3 6 4 1 0
Output
80
Note
In the first example, farmer Johnny can harvest all the bubbles by positioning the harvester on the first and the second row.
In the second example, one way Johnny can harvest maximum number of bubbles is to position the harvester in the second row, the fourth row, the second column and the fourth column.
Submitted Solution:
```
#
import heapq
n, m = map(int, input().split())
a = [list(map(int, input().split())) for _ in range(n)]
Q = []
# (sum, type, pos)
# 0: row, 1: col
minus = [[], []]
row = [0] * n
col = [0] * m
tol = [row, col]
for i in range(n):
row_ = 0
for j in range(m):
row_ += a[i][j]
row[i] = row_
heapq.heappush(Q, (row_ * -1, 0, i))
for j in range(m):
col_ = 0
for i in range(n):
col_ += a[i][j]
col[j] = col_
heapq.heappush(Q, (col_ * -1, 1, j))
def is_valid(Q, a, minus, tol):
sum_, type_, pos_ = Q[0]
sum_ *= -1
if type_ == 0:
if pos_ in minus[0]:
return False
minus_ = sum([ a[pos_][c] for c in minus[1] ])
if sum_ != tol[0][pos_] - minus_:
return False
else:
if pos_ in minus[1]:
return False
minus_ = sum([ a[r][pos_] for r in minus[0] ])
if sum_ != tol[1][pos_] - minus_:
return False
return True
S = 0
for _ in range(min(4, min(n, m))):
while is_valid(Q, a, minus, tol) == False :
heapq.heappop(Q)
sum_, type_, pos_ = heapq.heappop(Q)
S += -1 * sum_
minus[type_].append(pos_)
#print(type_, pos_)
minus_ = None
if type_ == 0:
for c in range(m):
if c in minus[1]: continue
minus_ = sum([ a[r][c] for r in minus[0] ])
new_sum = tol[1][c] - minus_
heapq.heappush(Q, ( -1*new_sum, 1, c ))
else:
for r in range(n):
if r in minus[0]: continue
minus_ = sum([ a[r][c] for c in minus[1] ])
new_sum = tol[0][r] - minus_
heapq.heappush(Q, ( -1*new_sum, 0, r ))
print(S)
#5 5
#0 9 2 7 0
#9 0 3 0 5
#0 8 0 3 1
#6 7 4 3 9
#3 6 4 1 0
#2 2
#1 2
#3 4
``` | instruction | 0 | 16,044 | 3 | 32,088 |
No | output | 1 | 16,044 | 3 | 32,089 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
It is Bubble Cup finals season and farmer Johnny Bubbles must harvest his bubbles. The bubbles are in a rectangular bubblefield formed of N x M square parcels divided into N rows and M columns. The parcel in i^{th} row and j^{th} column yields A_{i,j} bubbles.
Johnny Bubbles has available a very special self-driving bubble harvester that, once manually positioned at the beginning of a row or column, automatically harvests all the bubbles in that row or column. Once the harvester reaches the end of the row or column it stops and must be repositioned. The harvester can pass through any parcel any number of times, but it can collect bubbles from the parcel only once.
Johnny is very busy farmer, so he is available to manually position the harvester at most four times per day. Johnny is also impatient, so he wants to harvest as many bubbles as possible on the first day.
Please help Johnny to calculate what is the maximum number of bubbles he can collect on the first day.
Input
The first line contains two integers N and M (1 ≤ N, M ≤ N * M ≤ 10^{5}) - the bubblefield size.
Each of the next N lines contains M integers. The j^{th} element in the i^{th} line is A_{i,j} (0 ≤ a_{i,j} ≤ 10^{9}) — the yield of the parcel located in the i^{th} row and the j^{th} column.
Output
Output contains one integer number - maximum number of the bubbles Johnny can harvest on the first day.
Examples
Input
2 2
1 2
3 4
Output
10
Input
5 5
0 9 2 7 0
9 0 3 0 5
0 8 0 3 1
6 7 4 3 9
3 6 4 1 0
Output
80
Note
In the first example, farmer Johnny can harvest all the bubbles by positioning the harvester on the first and the second row.
In the second example, one way Johnny can harvest maximum number of bubbles is to position the harvester in the second row, the fourth row, the second column and the fourth column.
Submitted Solution:
```
from itertools import chain
N, M = tuple(map(int, input().split()))
A = []
row_sum = [0] * N
col_sum = [0] * M
for row in range(N):
line = []
for col, item in enumerate(input().split()):
value = int(item)
row_sum[row] += value
col_sum[col] += value
line.append(value)
A.append(line)
ans = 0
for _ in range(4):
max_v, pos = row_sum[0], 0
for i, value in enumerate(chain(row_sum, col_sum)):
if value > max_v:
max_v, pos = value, i
ans += max_v
if pos >= N:
col_sum[pos-N] = 0
for i in range(N):
row_sum[i] -= A[i][pos-N]
A[i][pos-N] = 0
else:
row_sum[pos] = 0
for i in range(M):
col_sum[i] -= A[pos][i]
A[pos][i] = 0
print(ans)
``` | instruction | 0 | 16,045 | 3 | 32,090 |
No | output | 1 | 16,045 | 3 | 32,091 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
The Two-dimensional kingdom is going through hard times... This morning the Three-Dimensional kingdom declared war on the Two-dimensional one. This (possibly armed) conflict will determine the ultimate owner of the straight line.
The Two-dimensional kingdom has a regular army of n people. Each soldier registered himself and indicated the desired size of the bulletproof vest: the i-th soldier indicated size ai. The soldiers are known to be unpretentious, so the command staff assumes that the soldiers are comfortable in any vests with sizes from ai - x to ai + y, inclusive (numbers x, y ≥ 0 are specified).
The Two-dimensional kingdom has m vests at its disposal, the j-th vest's size equals bj. Help mobilize the Two-dimensional kingdom's army: equip with vests as many soldiers as possible. Each vest can be used only once. The i-th soldier can put on the j-th vest, if ai - x ≤ bj ≤ ai + y.
Input
The first input line contains four integers n, m, x and y (1 ≤ n, m ≤ 105, 0 ≤ x, y ≤ 109) — the number of soldiers, the number of vests and two numbers that specify the soldiers' unpretentiousness, correspondingly.
The second line contains n integers a1, a2, ..., an (1 ≤ ai ≤ 109) in non-decreasing order, separated by single spaces — the desired sizes of vests.
The third line contains m integers b1, b2, ..., bm (1 ≤ bj ≤ 109) in non-decreasing order, separated by single spaces — the sizes of the available vests.
Output
In the first line print a single integer k — the maximum number of soldiers equipped with bulletproof vests.
In the next k lines print k pairs, one pair per line, as "ui vi" (without the quotes). Pair (ui, vi) means that soldier number ui must wear vest number vi. Soldiers and vests are numbered starting from one in the order in which they are specified in the input. All numbers of soldiers in the pairs should be pairwise different, all numbers of vests in the pairs also should be pairwise different. You can print the pairs in any order.
If there are multiple optimal answers, you are allowed to print any of them.
Examples
Input
5 3 0 0
1 2 3 3 4
1 3 5
Output
2
1 1
3 2
Input
3 3 2 2
1 5 9
3 5 7
Output
3
1 1
2 2
3 3
Note
In the first sample you need the vests' sizes to match perfectly: the first soldier gets the first vest (size 1), the third soldier gets the second vest (size 3). This sample allows another answer, which gives the second vest to the fourth soldier instead of the third one.
In the second sample the vest size can differ from the desired size by at most 2 sizes, so all soldiers can be equipped.
Submitted Solution:
```
n, m, a, b = map(int, input().split())
desired = list(map(int, input().split()))
available = list(map(int, input().split()))
desired = [(i, elem) for i, elem in enumerate(desired)]
available = [(i, elem) for i, elem in enumerate(available)]
# desired.sort(key = lambda x: x[0])
# available.sort(key = lambda x: x[0])
ans = []
ind1, ind2 = 0, 0
while ind1!=n and ind2!=m:
tup1, tup2 = desired[ind1], available[ind2]
if tup1[1] - a <= tup2[1] <= tup1[1] + b:
ind1 += 1
ind2 += 1
ans.append([tup1[0] + 1, tup2[0] + 1])
else:
if tup2[1] > tup1[1] + b:
ind1 += 1
else:
ind2 += 1
print(len(ans))
for pair in ans:
print(*pair)
``` | instruction | 0 | 16,234 | 3 | 32,468 |
Yes | output | 1 | 16,234 | 3 | 32,469 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
The Two-dimensional kingdom is going through hard times... This morning the Three-Dimensional kingdom declared war on the Two-dimensional one. This (possibly armed) conflict will determine the ultimate owner of the straight line.
The Two-dimensional kingdom has a regular army of n people. Each soldier registered himself and indicated the desired size of the bulletproof vest: the i-th soldier indicated size ai. The soldiers are known to be unpretentious, so the command staff assumes that the soldiers are comfortable in any vests with sizes from ai - x to ai + y, inclusive (numbers x, y ≥ 0 are specified).
The Two-dimensional kingdom has m vests at its disposal, the j-th vest's size equals bj. Help mobilize the Two-dimensional kingdom's army: equip with vests as many soldiers as possible. Each vest can be used only once. The i-th soldier can put on the j-th vest, if ai - x ≤ bj ≤ ai + y.
Input
The first input line contains four integers n, m, x and y (1 ≤ n, m ≤ 105, 0 ≤ x, y ≤ 109) — the number of soldiers, the number of vests and two numbers that specify the soldiers' unpretentiousness, correspondingly.
The second line contains n integers a1, a2, ..., an (1 ≤ ai ≤ 109) in non-decreasing order, separated by single spaces — the desired sizes of vests.
The third line contains m integers b1, b2, ..., bm (1 ≤ bj ≤ 109) in non-decreasing order, separated by single spaces — the sizes of the available vests.
Output
In the first line print a single integer k — the maximum number of soldiers equipped with bulletproof vests.
In the next k lines print k pairs, one pair per line, as "ui vi" (without the quotes). Pair (ui, vi) means that soldier number ui must wear vest number vi. Soldiers and vests are numbered starting from one in the order in which they are specified in the input. All numbers of soldiers in the pairs should be pairwise different, all numbers of vests in the pairs also should be pairwise different. You can print the pairs in any order.
If there are multiple optimal answers, you are allowed to print any of them.
Examples
Input
5 3 0 0
1 2 3 3 4
1 3 5
Output
2
1 1
3 2
Input
3 3 2 2
1 5 9
3 5 7
Output
3
1 1
2 2
3 3
Note
In the first sample you need the vests' sizes to match perfectly: the first soldier gets the first vest (size 1), the third soldier gets the second vest (size 3). This sample allows another answer, which gives the second vest to the fourth soldier instead of the third one.
In the second sample the vest size can differ from the desired size by at most 2 sizes, so all soldiers can be equipped.
Submitted Solution:
```
#!/usr/bin/python3
def readln(): return tuple(map(int, input().split()))
n, m, x, y = readln()
a = readln()
b = readln()
i = j = 0
ans = []
while i < len(a) and j < len(b):
if b[j] < a[i] - x:
j += 1
if j < len(b) and a[i] + y < b[j]:
i += 1
if i < len(a) and j < len(b) and (a[i] - x <= b[j] <= a[i] + y):
ans.append('%d %d' % (i + 1, j + 1))
i += 1
j += 1
print(len(ans))
print('\n'.join(ans))
``` | instruction | 0 | 16,235 | 3 | 32,470 |
Yes | output | 1 | 16,235 | 3 | 32,471 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
The Two-dimensional kingdom is going through hard times... This morning the Three-Dimensional kingdom declared war on the Two-dimensional one. This (possibly armed) conflict will determine the ultimate owner of the straight line.
The Two-dimensional kingdom has a regular army of n people. Each soldier registered himself and indicated the desired size of the bulletproof vest: the i-th soldier indicated size ai. The soldiers are known to be unpretentious, so the command staff assumes that the soldiers are comfortable in any vests with sizes from ai - x to ai + y, inclusive (numbers x, y ≥ 0 are specified).
The Two-dimensional kingdom has m vests at its disposal, the j-th vest's size equals bj. Help mobilize the Two-dimensional kingdom's army: equip with vests as many soldiers as possible. Each vest can be used only once. The i-th soldier can put on the j-th vest, if ai - x ≤ bj ≤ ai + y.
Input
The first input line contains four integers n, m, x and y (1 ≤ n, m ≤ 105, 0 ≤ x, y ≤ 109) — the number of soldiers, the number of vests and two numbers that specify the soldiers' unpretentiousness, correspondingly.
The second line contains n integers a1, a2, ..., an (1 ≤ ai ≤ 109) in non-decreasing order, separated by single spaces — the desired sizes of vests.
The third line contains m integers b1, b2, ..., bm (1 ≤ bj ≤ 109) in non-decreasing order, separated by single spaces — the sizes of the available vests.
Output
In the first line print a single integer k — the maximum number of soldiers equipped with bulletproof vests.
In the next k lines print k pairs, one pair per line, as "ui vi" (without the quotes). Pair (ui, vi) means that soldier number ui must wear vest number vi. Soldiers and vests are numbered starting from one in the order in which they are specified in the input. All numbers of soldiers in the pairs should be pairwise different, all numbers of vests in the pairs also should be pairwise different. You can print the pairs in any order.
If there are multiple optimal answers, you are allowed to print any of them.
Examples
Input
5 3 0 0
1 2 3 3 4
1 3 5
Output
2
1 1
3 2
Input
3 3 2 2
1 5 9
3 5 7
Output
3
1 1
2 2
3 3
Note
In the first sample you need the vests' sizes to match perfectly: the first soldier gets the first vest (size 1), the third soldier gets the second vest (size 3). This sample allows another answer, which gives the second vest to the fourth soldier instead of the third one.
In the second sample the vest size can differ from the desired size by at most 2 sizes, so all soldiers can be equipped.
Submitted Solution:
```
n, m, x, y = map(int, input().split())
a = list(map(int, input().split()))
b = list(map(int, input().split()))
i = 0
j = 0
cnt = 0
tcnt = 0
c = {}
while(i < n and j < m):
if a[i] - x <= b[j] and b[j] <= a[i] + y:
c[i] = j
i += 1
j += 1
tcnt += 1
elif b[j] < a[i] - x:
j += 1
else:
i += 1
print(len(c))
for i in c:
print(i + 1, c[i] + 1)
``` | instruction | 0 | 16,236 | 3 | 32,472 |
Yes | output | 1 | 16,236 | 3 | 32,473 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
The Two-dimensional kingdom is going through hard times... This morning the Three-Dimensional kingdom declared war on the Two-dimensional one. This (possibly armed) conflict will determine the ultimate owner of the straight line.
The Two-dimensional kingdom has a regular army of n people. Each soldier registered himself and indicated the desired size of the bulletproof vest: the i-th soldier indicated size ai. The soldiers are known to be unpretentious, so the command staff assumes that the soldiers are comfortable in any vests with sizes from ai - x to ai + y, inclusive (numbers x, y ≥ 0 are specified).
The Two-dimensional kingdom has m vests at its disposal, the j-th vest's size equals bj. Help mobilize the Two-dimensional kingdom's army: equip with vests as many soldiers as possible. Each vest can be used only once. The i-th soldier can put on the j-th vest, if ai - x ≤ bj ≤ ai + y.
Input
The first input line contains four integers n, m, x and y (1 ≤ n, m ≤ 105, 0 ≤ x, y ≤ 109) — the number of soldiers, the number of vests and two numbers that specify the soldiers' unpretentiousness, correspondingly.
The second line contains n integers a1, a2, ..., an (1 ≤ ai ≤ 109) in non-decreasing order, separated by single spaces — the desired sizes of vests.
The third line contains m integers b1, b2, ..., bm (1 ≤ bj ≤ 109) in non-decreasing order, separated by single spaces — the sizes of the available vests.
Output
In the first line print a single integer k — the maximum number of soldiers equipped with bulletproof vests.
In the next k lines print k pairs, one pair per line, as "ui vi" (without the quotes). Pair (ui, vi) means that soldier number ui must wear vest number vi. Soldiers and vests are numbered starting from one in the order in which they are specified in the input. All numbers of soldiers in the pairs should be pairwise different, all numbers of vests in the pairs also should be pairwise different. You can print the pairs in any order.
If there are multiple optimal answers, you are allowed to print any of them.
Examples
Input
5 3 0 0
1 2 3 3 4
1 3 5
Output
2
1 1
3 2
Input
3 3 2 2
1 5 9
3 5 7
Output
3
1 1
2 2
3 3
Note
In the first sample you need the vests' sizes to match perfectly: the first soldier gets the first vest (size 1), the third soldier gets the second vest (size 3). This sample allows another answer, which gives the second vest to the fourth soldier instead of the third one.
In the second sample the vest size can differ from the desired size by at most 2 sizes, so all soldiers can be equipped.
Submitted Solution:
```
first_line = list(map(int, input().split()))
n = first_line[0] # number of soldiers
m = first_line[1] # number of vests
x = first_line[2] # soldier's unpretentiousness indicator
y = first_line[3] # soldier's unpretentiousness indicator
a = list(map(int, input().split())) # desired sizes
b = list(map(int, input().split())) # available sizes
def main():
count = 0 # number of soldiers that can be provided with vests
ans = []
i, j = 0, 0
while i < n and j < m:
if a[i] - x <= b[j] and b[j] <= a[i] + y:
# soldier ith can wear the jth vest,
# so we try the next pair
count += 1
ans.append(str(i+1) + ' ' + str(j+1))
i += 1
j += 1
elif a[i] - x > b[j]:
# vest jth is too small, so we give
# soldier ith the next vest to try on
j += 1
# note: here we don't increase i because the next
# soldiers are no smaller in sizes than soldier ith,
# so the vest will still be too small for the next
# soldier in line
elif a[i] + y < b[j]:
# vest jth is too big, so we let the next soldier
# in line try on the vest
i += 1
# note: here we don't increase j as the next vests in line
# will just keep getting bigger, so soldier ith will not
# be able to find a vest that suits him.
print(count)
for p in ans:
print(p)
return
if __name__ == '__main__':
main()
# Time complexity: O(max(n,m))
``` | instruction | 0 | 16,237 | 3 | 32,474 |
Yes | output | 1 | 16,237 | 3 | 32,475 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
The Two-dimensional kingdom is going through hard times... This morning the Three-Dimensional kingdom declared war on the Two-dimensional one. This (possibly armed) conflict will determine the ultimate owner of the straight line.
The Two-dimensional kingdom has a regular army of n people. Each soldier registered himself and indicated the desired size of the bulletproof vest: the i-th soldier indicated size ai. The soldiers are known to be unpretentious, so the command staff assumes that the soldiers are comfortable in any vests with sizes from ai - x to ai + y, inclusive (numbers x, y ≥ 0 are specified).
The Two-dimensional kingdom has m vests at its disposal, the j-th vest's size equals bj. Help mobilize the Two-dimensional kingdom's army: equip with vests as many soldiers as possible. Each vest can be used only once. The i-th soldier can put on the j-th vest, if ai - x ≤ bj ≤ ai + y.
Input
The first input line contains four integers n, m, x and y (1 ≤ n, m ≤ 105, 0 ≤ x, y ≤ 109) — the number of soldiers, the number of vests and two numbers that specify the soldiers' unpretentiousness, correspondingly.
The second line contains n integers a1, a2, ..., an (1 ≤ ai ≤ 109) in non-decreasing order, separated by single spaces — the desired sizes of vests.
The third line contains m integers b1, b2, ..., bm (1 ≤ bj ≤ 109) in non-decreasing order, separated by single spaces — the sizes of the available vests.
Output
In the first line print a single integer k — the maximum number of soldiers equipped with bulletproof vests.
In the next k lines print k pairs, one pair per line, as "ui vi" (without the quotes). Pair (ui, vi) means that soldier number ui must wear vest number vi. Soldiers and vests are numbered starting from one in the order in which they are specified in the input. All numbers of soldiers in the pairs should be pairwise different, all numbers of vests in the pairs also should be pairwise different. You can print the pairs in any order.
If there are multiple optimal answers, you are allowed to print any of them.
Examples
Input
5 3 0 0
1 2 3 3 4
1 3 5
Output
2
1 1
3 2
Input
3 3 2 2
1 5 9
3 5 7
Output
3
1 1
2 2
3 3
Note
In the first sample you need the vests' sizes to match perfectly: the first soldier gets the first vest (size 1), the third soldier gets the second vest (size 3). This sample allows another answer, which gives the second vest to the fourth soldier instead of the third one.
In the second sample the vest size can differ from the desired size by at most 2 sizes, so all soldiers can be equipped.
Submitted Solution:
```
# http://codeforces.com/problemset/problem/161/A
n, m, x, y = list(map(int, input().split()))
a = list(map(int, input().split()))
b = list(map(int, input().split()))
j = 0
v = []
for i in range(m):
if j == n:
break
if j < n and a[j] - x <= b[i] <= a[j] + y:
v += [[j + 1, i + 1]]
j += 1
print(len(v))
for x in v:
print(x[0], x[1])
``` | instruction | 0 | 16,238 | 3 | 32,476 |
No | output | 1 | 16,238 | 3 | 32,477 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
The Two-dimensional kingdom is going through hard times... This morning the Three-Dimensional kingdom declared war on the Two-dimensional one. This (possibly armed) conflict will determine the ultimate owner of the straight line.
The Two-dimensional kingdom has a regular army of n people. Each soldier registered himself and indicated the desired size of the bulletproof vest: the i-th soldier indicated size ai. The soldiers are known to be unpretentious, so the command staff assumes that the soldiers are comfortable in any vests with sizes from ai - x to ai + y, inclusive (numbers x, y ≥ 0 are specified).
The Two-dimensional kingdom has m vests at its disposal, the j-th vest's size equals bj. Help mobilize the Two-dimensional kingdom's army: equip with vests as many soldiers as possible. Each vest can be used only once. The i-th soldier can put on the j-th vest, if ai - x ≤ bj ≤ ai + y.
Input
The first input line contains four integers n, m, x and y (1 ≤ n, m ≤ 105, 0 ≤ x, y ≤ 109) — the number of soldiers, the number of vests and two numbers that specify the soldiers' unpretentiousness, correspondingly.
The second line contains n integers a1, a2, ..., an (1 ≤ ai ≤ 109) in non-decreasing order, separated by single spaces — the desired sizes of vests.
The third line contains m integers b1, b2, ..., bm (1 ≤ bj ≤ 109) in non-decreasing order, separated by single spaces — the sizes of the available vests.
Output
In the first line print a single integer k — the maximum number of soldiers equipped with bulletproof vests.
In the next k lines print k pairs, one pair per line, as "ui vi" (without the quotes). Pair (ui, vi) means that soldier number ui must wear vest number vi. Soldiers and vests are numbered starting from one in the order in which they are specified in the input. All numbers of soldiers in the pairs should be pairwise different, all numbers of vests in the pairs also should be pairwise different. You can print the pairs in any order.
If there are multiple optimal answers, you are allowed to print any of them.
Examples
Input
5 3 0 0
1 2 3 3 4
1 3 5
Output
2
1 1
3 2
Input
3 3 2 2
1 5 9
3 5 7
Output
3
1 1
2 2
3 3
Note
In the first sample you need the vests' sizes to match perfectly: the first soldier gets the first vest (size 1), the third soldier gets the second vest (size 3). This sample allows another answer, which gives the second vest to the fourth soldier instead of the third one.
In the second sample the vest size can differ from the desired size by at most 2 sizes, so all soldiers can be equipped.
Submitted Solution:
```
def main():
n_soldiers, m_vests , x, y = [int(i) for i in input().split()]
soldiers = [int(i) for i in input().split()]
vests = [int(i) for i in input().split()]
j_start = 0
count = 0
suited_soldiers = []
for i in range(n_soldiers):
if j_start >= m_vests:
break
for j in range(j_start,m_vests):
if soldiers[i] < vests[j] - x :
break
if vests[j] - x <= soldiers[i] <= vests[j] + y: # vest fit soldier
count += 1
j_start += 1
suited_soldiers.append((i,j))
break
else:
break
print(count)
for idx_soldier, idx_vest in suited_soldiers:
print('%d %d' %( idx_soldier +1, idx_vest+1))
main()
``` | instruction | 0 | 16,239 | 3 | 32,478 |
No | output | 1 | 16,239 | 3 | 32,479 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
The Two-dimensional kingdom is going through hard times... This morning the Three-Dimensional kingdom declared war on the Two-dimensional one. This (possibly armed) conflict will determine the ultimate owner of the straight line.
The Two-dimensional kingdom has a regular army of n people. Each soldier registered himself and indicated the desired size of the bulletproof vest: the i-th soldier indicated size ai. The soldiers are known to be unpretentious, so the command staff assumes that the soldiers are comfortable in any vests with sizes from ai - x to ai + y, inclusive (numbers x, y ≥ 0 are specified).
The Two-dimensional kingdom has m vests at its disposal, the j-th vest's size equals bj. Help mobilize the Two-dimensional kingdom's army: equip with vests as many soldiers as possible. Each vest can be used only once. The i-th soldier can put on the j-th vest, if ai - x ≤ bj ≤ ai + y.
Input
The first input line contains four integers n, m, x and y (1 ≤ n, m ≤ 105, 0 ≤ x, y ≤ 109) — the number of soldiers, the number of vests and two numbers that specify the soldiers' unpretentiousness, correspondingly.
The second line contains n integers a1, a2, ..., an (1 ≤ ai ≤ 109) in non-decreasing order, separated by single spaces — the desired sizes of vests.
The third line contains m integers b1, b2, ..., bm (1 ≤ bj ≤ 109) in non-decreasing order, separated by single spaces — the sizes of the available vests.
Output
In the first line print a single integer k — the maximum number of soldiers equipped with bulletproof vests.
In the next k lines print k pairs, one pair per line, as "ui vi" (without the quotes). Pair (ui, vi) means that soldier number ui must wear vest number vi. Soldiers and vests are numbered starting from one in the order in which they are specified in the input. All numbers of soldiers in the pairs should be pairwise different, all numbers of vests in the pairs also should be pairwise different. You can print the pairs in any order.
If there are multiple optimal answers, you are allowed to print any of them.
Examples
Input
5 3 0 0
1 2 3 3 4
1 3 5
Output
2
1 1
3 2
Input
3 3 2 2
1 5 9
3 5 7
Output
3
1 1
2 2
3 3
Note
In the first sample you need the vests' sizes to match perfectly: the first soldier gets the first vest (size 1), the third soldier gets the second vest (size 3). This sample allows another answer, which gives the second vest to the fourth soldier instead of the third one.
In the second sample the vest size can differ from the desired size by at most 2 sizes, so all soldiers can be equipped.
Submitted Solution:
```
n, m, x, y = map(int, input().split())
arr = list(map(int, input().split()))
brr = list(map(int, input().split()))
count = 0
index = 0
results = []
for j in range(m):
start = index
end = n - 1
middle = (start + end) // 2
temp = [[-1, -1]]
while start <= end:
if (brr[j] >= (arr[middle] - x)) and (brr[j] <= (arr[middle] + y)):
temp[0][0] = middle + 1
temp[0][1] = j + 1
if start != end:
if arr[middle] <= arr[(n - 1) // 2]:
start = index
else:
start = (n - 1) // 2
end = middle - 1
middle = (start + end) // 2
else:
break
elif brr[j] < (arr[middle] - x):
end = middle - 1
middle = (start + end) // 2
else:
start = middle + 1
middle = (start + end) // 2
if temp[0][0] != -1:
count += 1
index = temp[0][0]
results.append([temp[0][0], temp[0][1]])
print(count)
for e in results:
print('{0} {1}'.format(e[0], e[1]))
``` | instruction | 0 | 16,240 | 3 | 32,480 |
No | output | 1 | 16,240 | 3 | 32,481 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
The Two-dimensional kingdom is going through hard times... This morning the Three-Dimensional kingdom declared war on the Two-dimensional one. This (possibly armed) conflict will determine the ultimate owner of the straight line.
The Two-dimensional kingdom has a regular army of n people. Each soldier registered himself and indicated the desired size of the bulletproof vest: the i-th soldier indicated size ai. The soldiers are known to be unpretentious, so the command staff assumes that the soldiers are comfortable in any vests with sizes from ai - x to ai + y, inclusive (numbers x, y ≥ 0 are specified).
The Two-dimensional kingdom has m vests at its disposal, the j-th vest's size equals bj. Help mobilize the Two-dimensional kingdom's army: equip with vests as many soldiers as possible. Each vest can be used only once. The i-th soldier can put on the j-th vest, if ai - x ≤ bj ≤ ai + y.
Input
The first input line contains four integers n, m, x and y (1 ≤ n, m ≤ 105, 0 ≤ x, y ≤ 109) — the number of soldiers, the number of vests and two numbers that specify the soldiers' unpretentiousness, correspondingly.
The second line contains n integers a1, a2, ..., an (1 ≤ ai ≤ 109) in non-decreasing order, separated by single spaces — the desired sizes of vests.
The third line contains m integers b1, b2, ..., bm (1 ≤ bj ≤ 109) in non-decreasing order, separated by single spaces — the sizes of the available vests.
Output
In the first line print a single integer k — the maximum number of soldiers equipped with bulletproof vests.
In the next k lines print k pairs, one pair per line, as "ui vi" (without the quotes). Pair (ui, vi) means that soldier number ui must wear vest number vi. Soldiers and vests are numbered starting from one in the order in which they are specified in the input. All numbers of soldiers in the pairs should be pairwise different, all numbers of vests in the pairs also should be pairwise different. You can print the pairs in any order.
If there are multiple optimal answers, you are allowed to print any of them.
Examples
Input
5 3 0 0
1 2 3 3 4
1 3 5
Output
2
1 1
3 2
Input
3 3 2 2
1 5 9
3 5 7
Output
3
1 1
2 2
3 3
Note
In the first sample you need the vests' sizes to match perfectly: the first soldier gets the first vest (size 1), the third soldier gets the second vest (size 3). This sample allows another answer, which gives the second vest to the fourth soldier instead of the third one.
In the second sample the vest size can differ from the desired size by at most 2 sizes, so all soldiers can be equipped.
Submitted Solution:
```
first_line = list(map(int, input().split()))
n = first_line[0]
m = first_line[1]
x = first_line[2]
y = first_line[3]
a = list(map(int, input().split()))
b = list(map(int, input().split()))
def main():
ans = []
cnt = []
for i in range(100001):
cnt.append(0)
for j in b:
if cnt[j] == 0:
cnt[j] += 1
last = 0 # remember where the last vest is available
count = 0 # number of vests to be taken
i = 0
while i < n:
# range to look for a vest
l = max(a[i] - x, last)
r = min(a[i] + y, len(cnt) - 1)
if l == r:
last = l
if cnt[l] == 1:
count += 1
cnt[l] -= 1
ans.append(str(i + 1) + ' ' + str(b.index(l) + 1))
j = l
while j <= r:
last = j
if cnt[j] == 1:
# a vest is available
count += 1
cnt[j] -= 1
ans.append(str(i + 1) + ' ' + str(b.index(j) + 1))
break
j += 1
i += 1
print(count)
for an in ans:
print(an)
return
if __name__ == '__main__':
main()
``` | instruction | 0 | 16,241 | 3 | 32,482 |
No | output | 1 | 16,241 | 3 | 32,483 |
Provide tags and a correct Python 3 solution for this coding contest problem.
When Valera was playing football on a stadium, it suddenly began to rain. Valera hid in the corridor under the grandstand not to get wet. However, the desire to play was so great that he decided to train his hitting the ball right in this corridor. Valera went back far enough, put the ball and hit it. The ball bounced off the walls, the ceiling and the floor corridor and finally hit the exit door. As the ball was wet, it left a spot on the door. Now Valera wants to know the coordinates for this spot.
Let's describe the event more formally. The ball will be considered a point in space. The door of the corridor will be considered a rectangle located on plane xOz, such that the lower left corner of the door is located at point (0, 0, 0), and the upper right corner is located at point (a, 0, b) . The corridor will be considered as a rectangular parallelepiped, infinite in the direction of increasing coordinates of y. In this corridor the floor will be considered as plane xOy, and the ceiling as plane, parallel to xOy and passing through point (a, 0, b). We will also assume that one of the walls is plane yOz, and the other wall is plane, parallel to yOz and passing through point (a, 0, b).
We'll say that the ball hit the door when its coordinate y was equal to 0. Thus the coordinates of the spot are point (x0, 0, z0), where 0 ≤ x0 ≤ a, 0 ≤ z0 ≤ b. To hit the ball, Valera steps away from the door at distance m and puts the ball in the center of the corridor at point <image>. After the hit the ball flies at speed (vx, vy, vz). This means that if the ball has coordinates (x, y, z), then after one second it will have coordinates (x + vx, y + vy, z + vz).
See image in notes for clarification.
When the ball collides with the ceiling, the floor or a wall of the corridor, it bounces off in accordance with the laws of reflection (the angle of incidence equals the angle of reflection). In the problem we consider the ideal physical model, so we can assume that there is no air resistance, friction force, or any loss of energy.
Input
The first line contains three space-separated integers a, b, m (1 ≤ a, b, m ≤ 100). The first two integers specify point (a, 0, b), through which the ceiling and one of the corridor walls pass. The third integer is the distance at which Valera went away from the door.
The second line has three space-separated integers vx, vy, vz (|vx|, |vy|, |vz| ≤ 100, vy < 0, vz ≥ 0) — the speed of the ball after the hit.
It is guaranteed that the ball hits the door.
Output
Print two real numbers x0, z0 — the x and z coordinates of point (x0, 0, z0), at which the ball hits the exit door. The answer will be considered correct, if its absolute or relative error does not exceed 10 - 6.
Examples
Input
7 2 11
3 -11 2
Output
6.5000000000 2.0000000000
Input
7 2 11
4 -3 3
Output
4.1666666667 1.0000000000
Note
<image> | instruction | 0 | 16,258 | 3 | 32,516 |
Tags: geometry, implementation, math
Correct Solution:
```
a,b,m=list(map(int,input().split(" ")))
vitesse=list(map(int,input().split(" ")))
necessary=m/abs(vitesse[1])
position=(a/2,m,0)
while position[1]>0:
if vitesse[2]>0:
time=(b-position[2])/vitesse[2]
elif vitesse[2]<0:
time=(position[2])/(-vitesse[2])
else:
time=m+1
if vitesse[0]>0:
tempo=(a-position[0])/vitesse[0]
elif vitesse[0]<0:
tempo=(-position[0])/vitesse[0]
else:
tempo=m+1
if tempo<time:
time=tempo
position=[position[i]+vitesse[i]*min(time,necessary) for i in range(3)]
if time<necessary:
vitesse[0]=-vitesse[0]
else:
break
elif tempo>time:
position=[position[i]+vitesse[i]*min(time,necessary) for i in range(3)]
if time<necessary:
vitesse[2]=-vitesse[2]
else:
break
else:
position=[position[i]+vitesse[i]*min(time,necessary) for i in range(3)]
if time<necessary:
vitesse[0],vitesse[2]=-vitesse[0],-vitesse[2]
else:
break
necessary-=time
print(position[0],position[2])
``` | output | 1 | 16,258 | 3 | 32,517 |
Provide tags and a correct Python 3 solution for this coding contest problem.
When Valera was playing football on a stadium, it suddenly began to rain. Valera hid in the corridor under the grandstand not to get wet. However, the desire to play was so great that he decided to train his hitting the ball right in this corridor. Valera went back far enough, put the ball and hit it. The ball bounced off the walls, the ceiling and the floor corridor and finally hit the exit door. As the ball was wet, it left a spot on the door. Now Valera wants to know the coordinates for this spot.
Let's describe the event more formally. The ball will be considered a point in space. The door of the corridor will be considered a rectangle located on plane xOz, such that the lower left corner of the door is located at point (0, 0, 0), and the upper right corner is located at point (a, 0, b) . The corridor will be considered as a rectangular parallelepiped, infinite in the direction of increasing coordinates of y. In this corridor the floor will be considered as plane xOy, and the ceiling as plane, parallel to xOy and passing through point (a, 0, b). We will also assume that one of the walls is plane yOz, and the other wall is plane, parallel to yOz and passing through point (a, 0, b).
We'll say that the ball hit the door when its coordinate y was equal to 0. Thus the coordinates of the spot are point (x0, 0, z0), where 0 ≤ x0 ≤ a, 0 ≤ z0 ≤ b. To hit the ball, Valera steps away from the door at distance m and puts the ball in the center of the corridor at point <image>. After the hit the ball flies at speed (vx, vy, vz). This means that if the ball has coordinates (x, y, z), then after one second it will have coordinates (x + vx, y + vy, z + vz).
See image in notes for clarification.
When the ball collides with the ceiling, the floor or a wall of the corridor, it bounces off in accordance with the laws of reflection (the angle of incidence equals the angle of reflection). In the problem we consider the ideal physical model, so we can assume that there is no air resistance, friction force, or any loss of energy.
Input
The first line contains three space-separated integers a, b, m (1 ≤ a, b, m ≤ 100). The first two integers specify point (a, 0, b), through which the ceiling and one of the corridor walls pass. The third integer is the distance at which Valera went away from the door.
The second line has three space-separated integers vx, vy, vz (|vx|, |vy|, |vz| ≤ 100, vy < 0, vz ≥ 0) — the speed of the ball after the hit.
It is guaranteed that the ball hits the door.
Output
Print two real numbers x0, z0 — the x and z coordinates of point (x0, 0, z0), at which the ball hits the exit door. The answer will be considered correct, if its absolute or relative error does not exceed 10 - 6.
Examples
Input
7 2 11
3 -11 2
Output
6.5000000000 2.0000000000
Input
7 2 11
4 -3 3
Output
4.1666666667 1.0000000000
Note
<image> | instruction | 0 | 16,259 | 3 | 32,518 |
Tags: geometry, implementation, math
Correct Solution:
```
from fractions import Fraction
from math import inf
a, b, m = map(int, input().split(' '))
x, y, z = map(int, input().split(' '))
cx, cy, cz = Fraction(a / 2), Fraction(m), Fraction(0)
while cy > 0:
if cx == 0:
x = abs(x)
elif cx == a:
x = -abs(x)
if cz == 0:
z = abs(z)
elif cz == b:
z = -abs(z)
if x == 0:
time_x = inf
elif x > 0:
time_x = (a - cx) / x
else:
time_x = cx / -x
time_y = -cy / y
if z == 0:
time_z = inf
elif z > 0:
time_z = (b - cz) / z
else:
time_z = cz / -z
time = min(time_x, time_y, time_z)
cx += time * x
cy += time * y
cz += time * z
print(float(cx), float(cz))
``` | output | 1 | 16,259 | 3 | 32,519 |
Provide tags and a correct Python 3 solution for this coding contest problem.
When Valera was playing football on a stadium, it suddenly began to rain. Valera hid in the corridor under the grandstand not to get wet. However, the desire to play was so great that he decided to train his hitting the ball right in this corridor. Valera went back far enough, put the ball and hit it. The ball bounced off the walls, the ceiling and the floor corridor and finally hit the exit door. As the ball was wet, it left a spot on the door. Now Valera wants to know the coordinates for this spot.
Let's describe the event more formally. The ball will be considered a point in space. The door of the corridor will be considered a rectangle located on plane xOz, such that the lower left corner of the door is located at point (0, 0, 0), and the upper right corner is located at point (a, 0, b) . The corridor will be considered as a rectangular parallelepiped, infinite in the direction of increasing coordinates of y. In this corridor the floor will be considered as plane xOy, and the ceiling as plane, parallel to xOy and passing through point (a, 0, b). We will also assume that one of the walls is plane yOz, and the other wall is plane, parallel to yOz and passing through point (a, 0, b).
We'll say that the ball hit the door when its coordinate y was equal to 0. Thus the coordinates of the spot are point (x0, 0, z0), where 0 ≤ x0 ≤ a, 0 ≤ z0 ≤ b. To hit the ball, Valera steps away from the door at distance m and puts the ball in the center of the corridor at point <image>. After the hit the ball flies at speed (vx, vy, vz). This means that if the ball has coordinates (x, y, z), then after one second it will have coordinates (x + vx, y + vy, z + vz).
See image in notes for clarification.
When the ball collides with the ceiling, the floor or a wall of the corridor, it bounces off in accordance with the laws of reflection (the angle of incidence equals the angle of reflection). In the problem we consider the ideal physical model, so we can assume that there is no air resistance, friction force, or any loss of energy.
Input
The first line contains three space-separated integers a, b, m (1 ≤ a, b, m ≤ 100). The first two integers specify point (a, 0, b), through which the ceiling and one of the corridor walls pass. The third integer is the distance at which Valera went away from the door.
The second line has three space-separated integers vx, vy, vz (|vx|, |vy|, |vz| ≤ 100, vy < 0, vz ≥ 0) — the speed of the ball after the hit.
It is guaranteed that the ball hits the door.
Output
Print two real numbers x0, z0 — the x and z coordinates of point (x0, 0, z0), at which the ball hits the exit door. The answer will be considered correct, if its absolute or relative error does not exceed 10 - 6.
Examples
Input
7 2 11
3 -11 2
Output
6.5000000000 2.0000000000
Input
7 2 11
4 -3 3
Output
4.1666666667 1.0000000000
Note
<image> | instruction | 0 | 16,260 | 3 | 32,520 |
Tags: geometry, implementation, math
Correct Solution:
```
def f(mx, tot):
while tot < 0 or tot > mx:
if tot > mx:
tot = 2 * mx - tot
else:
tot *= -1
return tot
a, b, m = map(int, input().split())
vx, vy, vz = map(int, input().split())
tm = m / -vy
print(f(a, a / 2 + vx * tm), f(b, vz * tm))
``` | output | 1 | 16,260 | 3 | 32,521 |
Provide tags and a correct Python 3 solution for this coding contest problem.
When Valera was playing football on a stadium, it suddenly began to rain. Valera hid in the corridor under the grandstand not to get wet. However, the desire to play was so great that he decided to train his hitting the ball right in this corridor. Valera went back far enough, put the ball and hit it. The ball bounced off the walls, the ceiling and the floor corridor and finally hit the exit door. As the ball was wet, it left a spot on the door. Now Valera wants to know the coordinates for this spot.
Let's describe the event more formally. The ball will be considered a point in space. The door of the corridor will be considered a rectangle located on plane xOz, such that the lower left corner of the door is located at point (0, 0, 0), and the upper right corner is located at point (a, 0, b) . The corridor will be considered as a rectangular parallelepiped, infinite in the direction of increasing coordinates of y. In this corridor the floor will be considered as plane xOy, and the ceiling as plane, parallel to xOy and passing through point (a, 0, b). We will also assume that one of the walls is plane yOz, and the other wall is plane, parallel to yOz and passing through point (a, 0, b).
We'll say that the ball hit the door when its coordinate y was equal to 0. Thus the coordinates of the spot are point (x0, 0, z0), where 0 ≤ x0 ≤ a, 0 ≤ z0 ≤ b. To hit the ball, Valera steps away from the door at distance m and puts the ball in the center of the corridor at point <image>. After the hit the ball flies at speed (vx, vy, vz). This means that if the ball has coordinates (x, y, z), then after one second it will have coordinates (x + vx, y + vy, z + vz).
See image in notes for clarification.
When the ball collides with the ceiling, the floor or a wall of the corridor, it bounces off in accordance with the laws of reflection (the angle of incidence equals the angle of reflection). In the problem we consider the ideal physical model, so we can assume that there is no air resistance, friction force, or any loss of energy.
Input
The first line contains three space-separated integers a, b, m (1 ≤ a, b, m ≤ 100). The first two integers specify point (a, 0, b), through which the ceiling and one of the corridor walls pass. The third integer is the distance at which Valera went away from the door.
The second line has three space-separated integers vx, vy, vz (|vx|, |vy|, |vz| ≤ 100, vy < 0, vz ≥ 0) — the speed of the ball after the hit.
It is guaranteed that the ball hits the door.
Output
Print two real numbers x0, z0 — the x and z coordinates of point (x0, 0, z0), at which the ball hits the exit door. The answer will be considered correct, if its absolute or relative error does not exceed 10 - 6.
Examples
Input
7 2 11
3 -11 2
Output
6.5000000000 2.0000000000
Input
7 2 11
4 -3 3
Output
4.1666666667 1.0000000000
Note
<image> | instruction | 0 | 16,261 | 3 | 32,522 |
Tags: geometry, implementation, math
Correct Solution:
```
# ========= /\ /| |====/|
# | / \ | | / |
# | /____\ | | / |
# | / \ | | / |
# ========= / \ ===== |/====|
# code
def main():
a,b,m = map(int , input().split())
v = [int(i) for i in input().split()]
pos = [a/2,m,0]
while pos[1] != 0:
# print(pos)
k = 1e9
j = -1
for i in range(3):
if v[i] == 0:
continue
if v[i] < 0:
t = pos[i]/(-1 * v[i])
if t < k:
k = t
j = i
else:
l = a if i == 0 else b
t = (l - pos[i])/v[i]
if t < k:
k = t
j = i
if v[j] < 0:
pos[j] = 0
for i in range(3):
if i != j:
pos[i] += v[i]*k
v[j] = -1 * v[j]
else:
pos[j] = a if j == 0 else b
for i in range(3):
if i != j:
pos[i] += v[i]*k
v[j] = -1 * v[j]
print(pos[0] , pos[2])
return
if __name__ == "__main__":
main()
``` | output | 1 | 16,261 | 3 | 32,523 |
Provide tags and a correct Python 3 solution for this coding contest problem.
When Valera was playing football on a stadium, it suddenly began to rain. Valera hid in the corridor under the grandstand not to get wet. However, the desire to play was so great that he decided to train his hitting the ball right in this corridor. Valera went back far enough, put the ball and hit it. The ball bounced off the walls, the ceiling and the floor corridor and finally hit the exit door. As the ball was wet, it left a spot on the door. Now Valera wants to know the coordinates for this spot.
Let's describe the event more formally. The ball will be considered a point in space. The door of the corridor will be considered a rectangle located on plane xOz, such that the lower left corner of the door is located at point (0, 0, 0), and the upper right corner is located at point (a, 0, b) . The corridor will be considered as a rectangular parallelepiped, infinite in the direction of increasing coordinates of y. In this corridor the floor will be considered as plane xOy, and the ceiling as plane, parallel to xOy and passing through point (a, 0, b). We will also assume that one of the walls is plane yOz, and the other wall is plane, parallel to yOz and passing through point (a, 0, b).
We'll say that the ball hit the door when its coordinate y was equal to 0. Thus the coordinates of the spot are point (x0, 0, z0), where 0 ≤ x0 ≤ a, 0 ≤ z0 ≤ b. To hit the ball, Valera steps away from the door at distance m and puts the ball in the center of the corridor at point <image>. After the hit the ball flies at speed (vx, vy, vz). This means that if the ball has coordinates (x, y, z), then after one second it will have coordinates (x + vx, y + vy, z + vz).
See image in notes for clarification.
When the ball collides with the ceiling, the floor or a wall of the corridor, it bounces off in accordance with the laws of reflection (the angle of incidence equals the angle of reflection). In the problem we consider the ideal physical model, so we can assume that there is no air resistance, friction force, or any loss of energy.
Input
The first line contains three space-separated integers a, b, m (1 ≤ a, b, m ≤ 100). The first two integers specify point (a, 0, b), through which the ceiling and one of the corridor walls pass. The third integer is the distance at which Valera went away from the door.
The second line has three space-separated integers vx, vy, vz (|vx|, |vy|, |vz| ≤ 100, vy < 0, vz ≥ 0) — the speed of the ball after the hit.
It is guaranteed that the ball hits the door.
Output
Print two real numbers x0, z0 — the x and z coordinates of point (x0, 0, z0), at which the ball hits the exit door. The answer will be considered correct, if its absolute or relative error does not exceed 10 - 6.
Examples
Input
7 2 11
3 -11 2
Output
6.5000000000 2.0000000000
Input
7 2 11
4 -3 3
Output
4.1666666667 1.0000000000
Note
<image> | instruction | 0 | 16,262 | 3 | 32,524 |
Tags: geometry, implementation, math
Correct Solution:
```
import sys
a, b, m = map(float, sys.stdin.readline().split(' '))
vx, vy, vz = map(float, sys.stdin.readline().split(' '))
time = m / abs(vy)
if vx < 0:
distx = a * 3 / 2 + time * abs(vx)
else:
distx = a * 1 / 2 + time * vx
distz = time * vz
k = int(distx / (2 * a))
distx -= k * 2 * a
k = int(distz / (2 * b))
distz -= k * 2 * b
if distx > a:
realx = 2 * a - distx
else:
realx = distx
if distz > b:
realz = 2 * b - distz
else:
realz = distz
print(realx, realz)
``` | output | 1 | 16,262 | 3 | 32,525 |
Provide tags and a correct Python 3 solution for this coding contest problem.
When Valera was playing football on a stadium, it suddenly began to rain. Valera hid in the corridor under the grandstand not to get wet. However, the desire to play was so great that he decided to train his hitting the ball right in this corridor. Valera went back far enough, put the ball and hit it. The ball bounced off the walls, the ceiling and the floor corridor and finally hit the exit door. As the ball was wet, it left a spot on the door. Now Valera wants to know the coordinates for this spot.
Let's describe the event more formally. The ball will be considered a point in space. The door of the corridor will be considered a rectangle located on plane xOz, such that the lower left corner of the door is located at point (0, 0, 0), and the upper right corner is located at point (a, 0, b) . The corridor will be considered as a rectangular parallelepiped, infinite in the direction of increasing coordinates of y. In this corridor the floor will be considered as plane xOy, and the ceiling as plane, parallel to xOy and passing through point (a, 0, b). We will also assume that one of the walls is plane yOz, and the other wall is plane, parallel to yOz and passing through point (a, 0, b).
We'll say that the ball hit the door when its coordinate y was equal to 0. Thus the coordinates of the spot are point (x0, 0, z0), where 0 ≤ x0 ≤ a, 0 ≤ z0 ≤ b. To hit the ball, Valera steps away from the door at distance m and puts the ball in the center of the corridor at point <image>. After the hit the ball flies at speed (vx, vy, vz). This means that if the ball has coordinates (x, y, z), then after one second it will have coordinates (x + vx, y + vy, z + vz).
See image in notes for clarification.
When the ball collides with the ceiling, the floor or a wall of the corridor, it bounces off in accordance with the laws of reflection (the angle of incidence equals the angle of reflection). In the problem we consider the ideal physical model, so we can assume that there is no air resistance, friction force, or any loss of energy.
Input
The first line contains three space-separated integers a, b, m (1 ≤ a, b, m ≤ 100). The first two integers specify point (a, 0, b), through which the ceiling and one of the corridor walls pass. The third integer is the distance at which Valera went away from the door.
The second line has three space-separated integers vx, vy, vz (|vx|, |vy|, |vz| ≤ 100, vy < 0, vz ≥ 0) — the speed of the ball after the hit.
It is guaranteed that the ball hits the door.
Output
Print two real numbers x0, z0 — the x and z coordinates of point (x0, 0, z0), at which the ball hits the exit door. The answer will be considered correct, if its absolute or relative error does not exceed 10 - 6.
Examples
Input
7 2 11
3 -11 2
Output
6.5000000000 2.0000000000
Input
7 2 11
4 -3 3
Output
4.1666666667 1.0000000000
Note
<image> | instruction | 0 | 16,263 | 3 | 32,526 |
Tags: geometry, implementation, math
Correct Solution:
```
R=lambda:map(int,input().split())
a,b,m=R()
x,y,z=R()
t=-m/y
x0=(a/2+t*x)%(2*a)
if x0>a:
x0=2*a-x0
z0=(t*z)%(2*b)
if z0>b:
z0=2*b-z0
print(x0,z0)
``` | output | 1 | 16,263 | 3 | 32,527 |
Provide tags and a correct Python 3 solution for this coding contest problem.
When Valera was playing football on a stadium, it suddenly began to rain. Valera hid in the corridor under the grandstand not to get wet. However, the desire to play was so great that he decided to train his hitting the ball right in this corridor. Valera went back far enough, put the ball and hit it. The ball bounced off the walls, the ceiling and the floor corridor and finally hit the exit door. As the ball was wet, it left a spot on the door. Now Valera wants to know the coordinates for this spot.
Let's describe the event more formally. The ball will be considered a point in space. The door of the corridor will be considered a rectangle located on plane xOz, such that the lower left corner of the door is located at point (0, 0, 0), and the upper right corner is located at point (a, 0, b) . The corridor will be considered as a rectangular parallelepiped, infinite in the direction of increasing coordinates of y. In this corridor the floor will be considered as plane xOy, and the ceiling as plane, parallel to xOy and passing through point (a, 0, b). We will also assume that one of the walls is plane yOz, and the other wall is plane, parallel to yOz and passing through point (a, 0, b).
We'll say that the ball hit the door when its coordinate y was equal to 0. Thus the coordinates of the spot are point (x0, 0, z0), where 0 ≤ x0 ≤ a, 0 ≤ z0 ≤ b. To hit the ball, Valera steps away from the door at distance m and puts the ball in the center of the corridor at point <image>. After the hit the ball flies at speed (vx, vy, vz). This means that if the ball has coordinates (x, y, z), then after one second it will have coordinates (x + vx, y + vy, z + vz).
See image in notes for clarification.
When the ball collides with the ceiling, the floor or a wall of the corridor, it bounces off in accordance with the laws of reflection (the angle of incidence equals the angle of reflection). In the problem we consider the ideal physical model, so we can assume that there is no air resistance, friction force, or any loss of energy.
Input
The first line contains three space-separated integers a, b, m (1 ≤ a, b, m ≤ 100). The first two integers specify point (a, 0, b), through which the ceiling and one of the corridor walls pass. The third integer is the distance at which Valera went away from the door.
The second line has three space-separated integers vx, vy, vz (|vx|, |vy|, |vz| ≤ 100, vy < 0, vz ≥ 0) — the speed of the ball after the hit.
It is guaranteed that the ball hits the door.
Output
Print two real numbers x0, z0 — the x and z coordinates of point (x0, 0, z0), at which the ball hits the exit door. The answer will be considered correct, if its absolute or relative error does not exceed 10 - 6.
Examples
Input
7 2 11
3 -11 2
Output
6.5000000000 2.0000000000
Input
7 2 11
4 -3 3
Output
4.1666666667 1.0000000000
Note
<image> | instruction | 0 | 16,264 | 3 | 32,528 |
Tags: geometry, implementation, math
Correct Solution:
```
a, b, m = [int(i) for i in input().split()]
vx, vy, vz = [int(i) for i in input().split()]
m = float(m)
t = m/abs(vy) # convert to time
x = (vx*t+a*.5)%(2*a)
z = vz*t % (2*b)
x = min(x, 2*a-x)
z = min(z, 2*b-z)
print(x,z)
``` | output | 1 | 16,264 | 3 | 32,529 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
Sean is trying to save a large file to a USB flash drive. He has n USB flash drives with capacities equal to a1, a2, ..., an megabytes. The file size is equal to m megabytes.
Find the minimum number of USB flash drives needed to write Sean's file, if he can split the file between drives.
Input
The first line contains positive integer n (1 ≤ n ≤ 100) — the number of USB flash drives.
The second line contains positive integer m (1 ≤ m ≤ 105) — the size of Sean's file.
Each of the next n lines contains positive integer ai (1 ≤ ai ≤ 1000) — the sizes of USB flash drives in megabytes.
It is guaranteed that the answer exists, i. e. the sum of all ai is not less than m.
Output
Print the minimum number of USB flash drives to write Sean's file, if he can split the file between drives.
Examples
Input
3
5
2
1
3
Output
2
Input
3
6
2
3
2
Output
3
Input
2
5
5
10
Output
1
Note
In the first example Sean needs only two USB flash drives — the first and the third.
In the second example Sean needs all three USB flash drives.
In the third example Sean needs only one USB flash drive and he can use any available USB flash drive — the first or the second.
Submitted Solution:
```
n=int(input())
m=int(input())
l=[]
for _ in range(n):
l.append(int(input()))
l.sort(reverse=True)
ans=0
for i in l:
if m>0:
m-=i
ans+=1
print(ans)
``` | instruction | 0 | 16,417 | 3 | 32,834 |
Yes | output | 1 | 16,417 | 3 | 32,835 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
Sean is trying to save a large file to a USB flash drive. He has n USB flash drives with capacities equal to a1, a2, ..., an megabytes. The file size is equal to m megabytes.
Find the minimum number of USB flash drives needed to write Sean's file, if he can split the file between drives.
Input
The first line contains positive integer n (1 ≤ n ≤ 100) — the number of USB flash drives.
The second line contains positive integer m (1 ≤ m ≤ 105) — the size of Sean's file.
Each of the next n lines contains positive integer ai (1 ≤ ai ≤ 1000) — the sizes of USB flash drives in megabytes.
It is guaranteed that the answer exists, i. e. the sum of all ai is not less than m.
Output
Print the minimum number of USB flash drives to write Sean's file, if he can split the file between drives.
Examples
Input
3
5
2
1
3
Output
2
Input
3
6
2
3
2
Output
3
Input
2
5
5
10
Output
1
Note
In the first example Sean needs only two USB flash drives — the first and the third.
In the second example Sean needs all three USB flash drives.
In the third example Sean needs only one USB flash drive and he can use any available USB flash drive — the first or the second.
Submitted Solution:
```
def function():
totalDrives=int(input())
fileSize=int(input())
drives=[]
for element in range(totalDrives):
temp=int(input())
drives.append(temp)
drives.sort()
currentSize=0
driveCount=0
while(currentSize<fileSize):
currentSize+=drives.pop()
driveCount+=1
return driveCount
print(function())
``` | instruction | 0 | 16,418 | 3 | 32,836 |
Yes | output | 1 | 16,418 | 3 | 32,837 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
Sean is trying to save a large file to a USB flash drive. He has n USB flash drives with capacities equal to a1, a2, ..., an megabytes. The file size is equal to m megabytes.
Find the minimum number of USB flash drives needed to write Sean's file, if he can split the file between drives.
Input
The first line contains positive integer n (1 ≤ n ≤ 100) — the number of USB flash drives.
The second line contains positive integer m (1 ≤ m ≤ 105) — the size of Sean's file.
Each of the next n lines contains positive integer ai (1 ≤ ai ≤ 1000) — the sizes of USB flash drives in megabytes.
It is guaranteed that the answer exists, i. e. the sum of all ai is not less than m.
Output
Print the minimum number of USB flash drives to write Sean's file, if he can split the file between drives.
Examples
Input
3
5
2
1
3
Output
2
Input
3
6
2
3
2
Output
3
Input
2
5
5
10
Output
1
Note
In the first example Sean needs only two USB flash drives — the first and the third.
In the second example Sean needs all three USB flash drives.
In the third example Sean needs only one USB flash drive and he can use any available USB flash drive — the first or the second.
Submitted Solution:
```
drives_cnt = int(input())
file = int(input())
drives = []
used_drives = []
for i in range(drives_cnt):
drives.append(int(input()))
sums = 0
for j in sorted(drives, reverse = True):
while sums < file:
sums = sums + j
used_drives.append(j)
print(len(used_drives))
``` | instruction | 0 | 16,420 | 3 | 32,840 |
No | output | 1 | 16,420 | 3 | 32,841 |
Provide tags and a correct Python 3 solution for this coding contest problem.
The Rebel fleet is afraid that the Empire might want to strike back again. Princess Heidi needs to know if it is possible to assign R Rebel spaceships to guard B bases so that every base has exactly one guardian and each spaceship has exactly one assigned base (in other words, the assignment is a perfect matching). Since she knows how reckless her pilots are, she wants to be sure that any two (straight) paths – from a base to its assigned spaceship – do not intersect in the galaxy plane (that is, in 2D), and so there is no risk of collision.
Input
The first line contains two space-separated integers R, B(1 ≤ R, B ≤ 10). For 1 ≤ i ≤ R, the i + 1-th line contains two space-separated integers xi and yi (|xi|, |yi| ≤ 10000) denoting the coordinates of the i-th Rebel spaceship. The following B lines have the same format, denoting the position of bases. It is guaranteed that no two points coincide and that no three points are on the same line.
Output
If it is possible to connect Rebel spaceships and bases so as satisfy the constraint, output Yes, otherwise output No (without quote).
Examples
Input
3 3
0 0
2 0
3 1
-2 1
0 3
2 2
Output
Yes
Input
2 1
1 0
2 2
3 1
Output
No
Note
For the first example, one possible way is to connect the Rebels and bases in order.
For the second example, there is no perfect matching between Rebels and bases. | instruction | 0 | 16,548 | 3 | 33,096 |
Tags: brute force, geometry, greedy, math
Correct Solution:
```
a, b = map(int, input().split())
if a == b:
print('Yes')
else:
print('No')
``` | output | 1 | 16,548 | 3 | 33,097 |
Provide tags and a correct Python 3 solution for this coding contest problem.
The Rebel fleet is afraid that the Empire might want to strike back again. Princess Heidi needs to know if it is possible to assign R Rebel spaceships to guard B bases so that every base has exactly one guardian and each spaceship has exactly one assigned base (in other words, the assignment is a perfect matching). Since she knows how reckless her pilots are, she wants to be sure that any two (straight) paths – from a base to its assigned spaceship – do not intersect in the galaxy plane (that is, in 2D), and so there is no risk of collision.
Input
The first line contains two space-separated integers R, B(1 ≤ R, B ≤ 10). For 1 ≤ i ≤ R, the i + 1-th line contains two space-separated integers xi and yi (|xi|, |yi| ≤ 10000) denoting the coordinates of the i-th Rebel spaceship. The following B lines have the same format, denoting the position of bases. It is guaranteed that no two points coincide and that no three points are on the same line.
Output
If it is possible to connect Rebel spaceships and bases so as satisfy the constraint, output Yes, otherwise output No (without quote).
Examples
Input
3 3
0 0
2 0
3 1
-2 1
0 3
2 2
Output
Yes
Input
2 1
1 0
2 2
3 1
Output
No
Note
For the first example, one possible way is to connect the Rebels and bases in order.
For the second example, there is no perfect matching between Rebels and bases. | instruction | 0 | 16,549 | 3 | 33,098 |
Tags: brute force, geometry, greedy, math
Correct Solution:
```
R, B = map(int, input().split())
print(('No', 'Yes')[R == B])
``` | output | 1 | 16,549 | 3 | 33,099 |
Provide tags and a correct Python 3 solution for this coding contest problem.
The Rebel fleet is afraid that the Empire might want to strike back again. Princess Heidi needs to know if it is possible to assign R Rebel spaceships to guard B bases so that every base has exactly one guardian and each spaceship has exactly one assigned base (in other words, the assignment is a perfect matching). Since she knows how reckless her pilots are, she wants to be sure that any two (straight) paths – from a base to its assigned spaceship – do not intersect in the galaxy plane (that is, in 2D), and so there is no risk of collision.
Input
The first line contains two space-separated integers R, B(1 ≤ R, B ≤ 10). For 1 ≤ i ≤ R, the i + 1-th line contains two space-separated integers xi and yi (|xi|, |yi| ≤ 10000) denoting the coordinates of the i-th Rebel spaceship. The following B lines have the same format, denoting the position of bases. It is guaranteed that no two points coincide and that no three points are on the same line.
Output
If it is possible to connect Rebel spaceships and bases so as satisfy the constraint, output Yes, otherwise output No (without quote).
Examples
Input
3 3
0 0
2 0
3 1
-2 1
0 3
2 2
Output
Yes
Input
2 1
1 0
2 2
3 1
Output
No
Note
For the first example, one possible way is to connect the Rebels and bases in order.
For the second example, there is no perfect matching between Rebels and bases. | instruction | 0 | 16,550 | 3 | 33,100 |
Tags: brute force, geometry, greedy, math
Correct Solution:
```
n,m=map(int,input().split())
for i in range(n+m):
a=input()
if(n==m):
print("YES")
else:
print("NO")
``` | output | 1 | 16,550 | 3 | 33,101 |
Provide tags and a correct Python 3 solution for this coding contest problem.
The Rebel fleet is afraid that the Empire might want to strike back again. Princess Heidi needs to know if it is possible to assign R Rebel spaceships to guard B bases so that every base has exactly one guardian and each spaceship has exactly one assigned base (in other words, the assignment is a perfect matching). Since she knows how reckless her pilots are, she wants to be sure that any two (straight) paths – from a base to its assigned spaceship – do not intersect in the galaxy plane (that is, in 2D), and so there is no risk of collision.
Input
The first line contains two space-separated integers R, B(1 ≤ R, B ≤ 10). For 1 ≤ i ≤ R, the i + 1-th line contains two space-separated integers xi and yi (|xi|, |yi| ≤ 10000) denoting the coordinates of the i-th Rebel spaceship. The following B lines have the same format, denoting the position of bases. It is guaranteed that no two points coincide and that no three points are on the same line.
Output
If it is possible to connect Rebel spaceships and bases so as satisfy the constraint, output Yes, otherwise output No (without quote).
Examples
Input
3 3
0 0
2 0
3 1
-2 1
0 3
2 2
Output
Yes
Input
2 1
1 0
2 2
3 1
Output
No
Note
For the first example, one possible way is to connect the Rebels and bases in order.
For the second example, there is no perfect matching between Rebels and bases. | instruction | 0 | 16,551 | 3 | 33,102 |
Tags: brute force, geometry, greedy, math
Correct Solution:
```
def ccw(A, B, C):
return (C[1] - A[1]) * (B[0] - A[0]) > (B[1] - A[1]) * (C[0] - A[0])
def intersect(A, B, C, D):
return ccw(A, C, D) != ccw(B, C, D) and ccw(A, B, C) != ccw(A, B, D)
R, B = map(int, input().split())
rs = []
bs = []
for r in range(R):
rs.append(list(map(int, input().split())))
for r in range(B):
bs.append(list(map(int, input().split())))
if R != B:
print('No')
else:
def rec(at, done, remain):
if at >= B:
return True
for b in remain:
for r, d in zip(rs, done):
if intersect(r, bs[d], rs[at], bs[b]):
break
else:
ok = rec(at + 1, done + [b], remain - {b})
if ok:
return True
return False
print(['NO', 'YES'][rec(0, [], set(range(B)))])
``` | output | 1 | 16,551 | 3 | 33,103 |
Provide tags and a correct Python 3 solution for this coding contest problem.
The Rebel fleet is afraid that the Empire might want to strike back again. Princess Heidi needs to know if it is possible to assign R Rebel spaceships to guard B bases so that every base has exactly one guardian and each spaceship has exactly one assigned base (in other words, the assignment is a perfect matching). Since she knows how reckless her pilots are, she wants to be sure that any two (straight) paths – from a base to its assigned spaceship – do not intersect in the galaxy plane (that is, in 2D), and so there is no risk of collision.
Input
The first line contains two space-separated integers R, B(1 ≤ R, B ≤ 10). For 1 ≤ i ≤ R, the i + 1-th line contains two space-separated integers xi and yi (|xi|, |yi| ≤ 10000) denoting the coordinates of the i-th Rebel spaceship. The following B lines have the same format, denoting the position of bases. It is guaranteed that no two points coincide and that no three points are on the same line.
Output
If it is possible to connect Rebel spaceships and bases so as satisfy the constraint, output Yes, otherwise output No (without quote).
Examples
Input
3 3
0 0
2 0
3 1
-2 1
0 3
2 2
Output
Yes
Input
2 1
1 0
2 2
3 1
Output
No
Note
For the first example, one possible way is to connect the Rebels and bases in order.
For the second example, there is no perfect matching between Rebels and bases. | instruction | 0 | 16,552 | 3 | 33,104 |
Tags: brute force, geometry, greedy, math
Correct Solution:
```
r, b = map(int,input().split())
print(('No', 'Yes')[r == b])
``` | output | 1 | 16,552 | 3 | 33,105 |
Provide tags and a correct Python 3 solution for this coding contest problem.
The Rebel fleet is afraid that the Empire might want to strike back again. Princess Heidi needs to know if it is possible to assign R Rebel spaceships to guard B bases so that every base has exactly one guardian and each spaceship has exactly one assigned base (in other words, the assignment is a perfect matching). Since she knows how reckless her pilots are, she wants to be sure that any two (straight) paths – from a base to its assigned spaceship – do not intersect in the galaxy plane (that is, in 2D), and so there is no risk of collision.
Input
The first line contains two space-separated integers R, B(1 ≤ R, B ≤ 10). For 1 ≤ i ≤ R, the i + 1-th line contains two space-separated integers xi and yi (|xi|, |yi| ≤ 10000) denoting the coordinates of the i-th Rebel spaceship. The following B lines have the same format, denoting the position of bases. It is guaranteed that no two points coincide and that no three points are on the same line.
Output
If it is possible to connect Rebel spaceships and bases so as satisfy the constraint, output Yes, otherwise output No (without quote).
Examples
Input
3 3
0 0
2 0
3 1
-2 1
0 3
2 2
Output
Yes
Input
2 1
1 0
2 2
3 1
Output
No
Note
For the first example, one possible way is to connect the Rebels and bases in order.
For the second example, there is no perfect matching between Rebels and bases. | instruction | 0 | 16,553 | 3 | 33,106 |
Tags: brute force, geometry, greedy, math
Correct Solution:
```
a = input().split()
if a[0] == a[1]:
print("YES")
else:
print("NO")
``` | output | 1 | 16,553 | 3 | 33,107 |
Provide tags and a correct Python 3 solution for this coding contest problem.
The Rebel fleet is afraid that the Empire might want to strike back again. Princess Heidi needs to know if it is possible to assign R Rebel spaceships to guard B bases so that every base has exactly one guardian and each spaceship has exactly one assigned base (in other words, the assignment is a perfect matching). Since she knows how reckless her pilots are, she wants to be sure that any two (straight) paths – from a base to its assigned spaceship – do not intersect in the galaxy plane (that is, in 2D), and so there is no risk of collision.
Input
The first line contains two space-separated integers R, B(1 ≤ R, B ≤ 10). For 1 ≤ i ≤ R, the i + 1-th line contains two space-separated integers xi and yi (|xi|, |yi| ≤ 10000) denoting the coordinates of the i-th Rebel spaceship. The following B lines have the same format, denoting the position of bases. It is guaranteed that no two points coincide and that no three points are on the same line.
Output
If it is possible to connect Rebel spaceships and bases so as satisfy the constraint, output Yes, otherwise output No (without quote).
Examples
Input
3 3
0 0
2 0
3 1
-2 1
0 3
2 2
Output
Yes
Input
2 1
1 0
2 2
3 1
Output
No
Note
For the first example, one possible way is to connect the Rebels and bases in order.
For the second example, there is no perfect matching between Rebels and bases. | instruction | 0 | 16,554 | 3 | 33,108 |
Tags: brute force, geometry, greedy, math
Correct Solution:
```
r, b = map(int, input().split())
for i in range(r + b):
l = input().split()
if r == b:
print('Yes')
else:
print('No')
``` | output | 1 | 16,554 | 3 | 33,109 |
Provide tags and a correct Python 3 solution for this coding contest problem.
The Rebel fleet is afraid that the Empire might want to strike back again. Princess Heidi needs to know if it is possible to assign R Rebel spaceships to guard B bases so that every base has exactly one guardian and each spaceship has exactly one assigned base (in other words, the assignment is a perfect matching). Since she knows how reckless her pilots are, she wants to be sure that any two (straight) paths – from a base to its assigned spaceship – do not intersect in the galaxy plane (that is, in 2D), and so there is no risk of collision.
Input
The first line contains two space-separated integers R, B(1 ≤ R, B ≤ 10). For 1 ≤ i ≤ R, the i + 1-th line contains two space-separated integers xi and yi (|xi|, |yi| ≤ 10000) denoting the coordinates of the i-th Rebel spaceship. The following B lines have the same format, denoting the position of bases. It is guaranteed that no two points coincide and that no three points are on the same line.
Output
If it is possible to connect Rebel spaceships and bases so as satisfy the constraint, output Yes, otherwise output No (without quote).
Examples
Input
3 3
0 0
2 0
3 1
-2 1
0 3
2 2
Output
Yes
Input
2 1
1 0
2 2
3 1
Output
No
Note
For the first example, one possible way is to connect the Rebels and bases in order.
For the second example, there is no perfect matching between Rebels and bases. | instruction | 0 | 16,555 | 3 | 33,110 |
Tags: brute force, geometry, greedy, math
Correct Solution:
```
x,y=map(int,input().split())
for k in range(x+y):
a=input()
if x==y:
print("Yes")
else:
print("No")
``` | output | 1 | 16,555 | 3 | 33,111 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
The Rebel fleet is afraid that the Empire might want to strike back again. Princess Heidi needs to know if it is possible to assign R Rebel spaceships to guard B bases so that every base has exactly one guardian and each spaceship has exactly one assigned base (in other words, the assignment is a perfect matching). Since she knows how reckless her pilots are, she wants to be sure that any two (straight) paths – from a base to its assigned spaceship – do not intersect in the galaxy plane (that is, in 2D), and so there is no risk of collision.
Input
The first line contains two space-separated integers R, B(1 ≤ R, B ≤ 10). For 1 ≤ i ≤ R, the i + 1-th line contains two space-separated integers xi and yi (|xi|, |yi| ≤ 10000) denoting the coordinates of the i-th Rebel spaceship. The following B lines have the same format, denoting the position of bases. It is guaranteed that no two points coincide and that no three points are on the same line.
Output
If it is possible to connect Rebel spaceships and bases so as satisfy the constraint, output Yes, otherwise output No (without quote).
Examples
Input
3 3
0 0
2 0
3 1
-2 1
0 3
2 2
Output
Yes
Input
2 1
1 0
2 2
3 1
Output
No
Note
For the first example, one possible way is to connect the Rebels and bases in order.
For the second example, there is no perfect matching between Rebels and bases.
Submitted Solution:
```
#Code by Sounak, IIESTS
#------------------------------warmup----------------------------
import os
import sys
import math
from io import BytesIO, IOBase
BUFSIZE = 8192
class FastIO(IOBase):
newlines = 0
def __init__(self, file):
self._fd = file.fileno()
self.buffer = BytesIO()
self.writable = "x" in file.mode or "r" not in file.mode
self.write = self.buffer.write if self.writable else None
def read(self):
while True:
b = os.read(self._fd, max(os.fstat(self._fd).st_size, BUFSIZE))
if not b:
break
ptr = self.buffer.tell()
self.buffer.seek(0, 2), self.buffer.write(b), self.buffer.seek(ptr)
self.newlines = 0
return self.buffer.read()
def readline(self):
while self.newlines == 0:
b = os.read(self._fd, max(os.fstat(self._fd).st_size, BUFSIZE))
self.newlines = b.count(b"\n") + (not b)
ptr = self.buffer.tell()
self.buffer.seek(0, 2), self.buffer.write(b), self.buffer.seek(ptr)
self.newlines -= 1
return self.buffer.readline()
def flush(self):
if self.writable:
os.write(self._fd, self.buffer.getvalue())
self.buffer.truncate(0), self.buffer.seek(0)
class IOWrapper(IOBase):
def __init__(self, file):
self.buffer = FastIO(file)
self.flush = self.buffer.flush
self.writable = self.buffer.writable
self.write = lambda s: self.buffer.write(s.encode("ascii"))
self.read = lambda: self.buffer.read().decode("ascii")
self.readline = lambda: self.buffer.readline().decode("ascii")
sys.stdin, sys.stdout = IOWrapper(sys.stdin), IOWrapper(sys.stdout)
input = lambda: sys.stdin.readline().rstrip("\r\n")
#-------------------game starts now-----------------------------------------------------
n,k=map(int,input().split())
for i in range (n):
a,b=map(int,input().split())
for i in range (k):
a,b=map(int,input().split())
if n==k:
print("YES")
else:
print("NO")
``` | instruction | 0 | 16,556 | 3 | 33,112 |
Yes | output | 1 | 16,556 | 3 | 33,113 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
The Rebel fleet is afraid that the Empire might want to strike back again. Princess Heidi needs to know if it is possible to assign R Rebel spaceships to guard B bases so that every base has exactly one guardian and each spaceship has exactly one assigned base (in other words, the assignment is a perfect matching). Since she knows how reckless her pilots are, she wants to be sure that any two (straight) paths – from a base to its assigned spaceship – do not intersect in the galaxy plane (that is, in 2D), and so there is no risk of collision.
Input
The first line contains two space-separated integers R, B(1 ≤ R, B ≤ 10). For 1 ≤ i ≤ R, the i + 1-th line contains two space-separated integers xi and yi (|xi|, |yi| ≤ 10000) denoting the coordinates of the i-th Rebel spaceship. The following B lines have the same format, denoting the position of bases. It is guaranteed that no two points coincide and that no three points are on the same line.
Output
If it is possible to connect Rebel spaceships and bases so as satisfy the constraint, output Yes, otherwise output No (without quote).
Examples
Input
3 3
0 0
2 0
3 1
-2 1
0 3
2 2
Output
Yes
Input
2 1
1 0
2 2
3 1
Output
No
Note
For the first example, one possible way is to connect the Rebels and bases in order.
For the second example, there is no perfect matching between Rebels and bases.
Submitted Solution:
```
b,r = input().split()
#print("b = ",b)
for x in range(int(b)):
temp,temp = input().split()
for x in range(int(r)):
temp,temp = input().split()
if(b==r):
print("Yes")
else:
print("No")
``` | instruction | 0 | 16,557 | 3 | 33,114 |
Yes | output | 1 | 16,557 | 3 | 33,115 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
The Rebel fleet is afraid that the Empire might want to strike back again. Princess Heidi needs to know if it is possible to assign R Rebel spaceships to guard B bases so that every base has exactly one guardian and each spaceship has exactly one assigned base (in other words, the assignment is a perfect matching). Since she knows how reckless her pilots are, she wants to be sure that any two (straight) paths – from a base to its assigned spaceship – do not intersect in the galaxy plane (that is, in 2D), and so there is no risk of collision.
Input
The first line contains two space-separated integers R, B(1 ≤ R, B ≤ 10). For 1 ≤ i ≤ R, the i + 1-th line contains two space-separated integers xi and yi (|xi|, |yi| ≤ 10000) denoting the coordinates of the i-th Rebel spaceship. The following B lines have the same format, denoting the position of bases. It is guaranteed that no two points coincide and that no three points are on the same line.
Output
If it is possible to connect Rebel spaceships and bases so as satisfy the constraint, output Yes, otherwise output No (without quote).
Examples
Input
3 3
0 0
2 0
3 1
-2 1
0 3
2 2
Output
Yes
Input
2 1
1 0
2 2
3 1
Output
No
Note
For the first example, one possible way is to connect the Rebels and bases in order.
For the second example, there is no perfect matching between Rebels and bases.
Submitted Solution:
```
a,b = map(int,input().split())
for i in range(a+b):
n,m = map(int,input().split())
if a == b:
print('Yes')
else:
print('No')
``` | instruction | 0 | 16,558 | 3 | 33,116 |
Yes | output | 1 | 16,558 | 3 | 33,117 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
The Rebel fleet is afraid that the Empire might want to strike back again. Princess Heidi needs to know if it is possible to assign R Rebel spaceships to guard B bases so that every base has exactly one guardian and each spaceship has exactly one assigned base (in other words, the assignment is a perfect matching). Since she knows how reckless her pilots are, she wants to be sure that any two (straight) paths – from a base to its assigned spaceship – do not intersect in the galaxy plane (that is, in 2D), and so there is no risk of collision.
Input
The first line contains two space-separated integers R, B(1 ≤ R, B ≤ 10). For 1 ≤ i ≤ R, the i + 1-th line contains two space-separated integers xi and yi (|xi|, |yi| ≤ 10000) denoting the coordinates of the i-th Rebel spaceship. The following B lines have the same format, denoting the position of bases. It is guaranteed that no two points coincide and that no three points are on the same line.
Output
If it is possible to connect Rebel spaceships and bases so as satisfy the constraint, output Yes, otherwise output No (without quote).
Examples
Input
3 3
0 0
2 0
3 1
-2 1
0 3
2 2
Output
Yes
Input
2 1
1 0
2 2
3 1
Output
No
Note
For the first example, one possible way is to connect the Rebels and bases in order.
For the second example, there is no perfect matching between Rebels and bases.
Submitted Solution:
```
l = input().split(' ')
print("Yes" if int(l[0]) == int(l[1]) else "No")
``` | instruction | 0 | 16,559 | 3 | 33,118 |
Yes | output | 1 | 16,559 | 3 | 33,119 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
The Rebel fleet is afraid that the Empire might want to strike back again. Princess Heidi needs to know if it is possible to assign R Rebel spaceships to guard B bases so that every base has exactly one guardian and each spaceship has exactly one assigned base (in other words, the assignment is a perfect matching). Since she knows how reckless her pilots are, she wants to be sure that any two (straight) paths – from a base to its assigned spaceship – do not intersect in the galaxy plane (that is, in 2D), and so there is no risk of collision.
Input
The first line contains two space-separated integers R, B(1 ≤ R, B ≤ 10). For 1 ≤ i ≤ R, the i + 1-th line contains two space-separated integers xi and yi (|xi|, |yi| ≤ 10000) denoting the coordinates of the i-th Rebel spaceship. The following B lines have the same format, denoting the position of bases. It is guaranteed that no two points coincide and that no three points are on the same line.
Output
If it is possible to connect Rebel spaceships and bases so as satisfy the constraint, output Yes, otherwise output No (without quote).
Examples
Input
3 3
0 0
2 0
3 1
-2 1
0 3
2 2
Output
Yes
Input
2 1
1 0
2 2
3 1
Output
No
Note
For the first example, one possible way is to connect the Rebels and bases in order.
For the second example, there is no perfect matching between Rebels and bases.
Submitted Solution:
```
def check(a,b):
ansa=b[0]-a[0]
ansb=b[1]-a[1]
return [ansa,ansb]
while True:
try:
n,m=map(int,input().split())
if n!=m:
print('No')
else:
a=list()
b=list()
for i in range(n):
a.append(list(map(int,input().split())))
for i in range(m):
b.append(list(map(int,input().split())))
flag=False
for i in range(len(a)):
for j in range(i+1,len(a)):
for k in range(len(b)):
for l in range(k+1,len(b)):
ansa=check(a[i],a[j])
ansb=check(a[i],b[k])
ansc=check(a[i],b[l])
if (ansa[0]==ansb[0] and ansa[0]==ansc[0] and ansa[0]==0) or (ansa[0]!=0 and ansb[0]!=0 and ansc[0]!=0 and ansa[1]/ansa[0]==ansb[1]/ansb[0] and ansa[1]/ansa[0]==ansc[1]/ansc[0]):
print('No')
flag=True
break
else:
continue
if flag==True:
break
if flag==True:
break
if flag==True:
break
if flag==False:
print('Yes')
except EOFError:
break
``` | instruction | 0 | 16,560 | 3 | 33,120 |
No | output | 1 | 16,560 | 3 | 33,121 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
The Rebel fleet is afraid that the Empire might want to strike back again. Princess Heidi needs to know if it is possible to assign R Rebel spaceships to guard B bases so that every base has exactly one guardian and each spaceship has exactly one assigned base (in other words, the assignment is a perfect matching). Since she knows how reckless her pilots are, she wants to be sure that any two (straight) paths – from a base to its assigned spaceship – do not intersect in the galaxy plane (that is, in 2D), and so there is no risk of collision.
Input
The first line contains two space-separated integers R, B(1 ≤ R, B ≤ 10). For 1 ≤ i ≤ R, the i + 1-th line contains two space-separated integers xi and yi (|xi|, |yi| ≤ 10000) denoting the coordinates of the i-th Rebel spaceship. The following B lines have the same format, denoting the position of bases. It is guaranteed that no two points coincide and that no three points are on the same line.
Output
If it is possible to connect Rebel spaceships and bases so as satisfy the constraint, output Yes, otherwise output No (without quote).
Examples
Input
3 3
0 0
2 0
3 1
-2 1
0 3
2 2
Output
Yes
Input
2 1
1 0
2 2
3 1
Output
No
Note
For the first example, one possible way is to connect the Rebels and bases in order.
For the second example, there is no perfect matching between Rebels and bases.
Submitted Solution:
```
s = input()
in1 = s.split(' ')
R = int(in1[0])
B = int(in1[1])
print(R==B)
``` | instruction | 0 | 16,561 | 3 | 33,122 |
No | output | 1 | 16,561 | 3 | 33,123 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
You are enthusiastic about the popular web game "Moonlight Ranch". The purpose of this game is to grow crops in the fields, sell them to earn income, and use that income to grow the ranch.
You wanted to grow the field quickly. Therefore, we decided to arrange the crops that can be grown in the game based on the income efficiency per hour.
You have to buy seeds to grow crops. Here, the name of the species of crop i is given by Li, and the price is given by Pi. When seeds are planted in the field, they sprout after time Ai. Young leaves appear 2 hours after the buds emerge. The leaves grow thick after Ci. The flowers bloom 10 hours after the leaves grow. Fruits come out time Ei after the flowers bloom. One seed produces Fi fruits, each of which sells at the price of Si. Some crops are multi-stage crops and bear a total of Mi fruit. In the case of a single-stage crop, it is represented by Mi = 1. Multi-season crops return to leaves after fruiting until the Mith fruit. The income for a seed is the amount of money sold for all the fruits of that seed minus the price of the seed. In addition, the income efficiency of the seed is the value obtained by dividing the income by the time from planting the seed to the completion of all the fruits.
Your job is to write a program that sorts and outputs crop information given as input, sorted in descending order of income efficiency.
Input
The input is a sequence of datasets, and each dataset is given in the following format.
> N
> L1 P1 A1 B1 C1 D1 E1 F1 S1 M1
> L2 P2 A2 B2 C2 D2 E2 F2 S2 M2
> ...
> LN PN AN BN CN DN EN FN SN MN
>
The first line is the number of crops N in the dataset (1 ≤ N ≤ 50).
The N lines that follow contain information about one crop in each line. The meaning of each variable is as described in the problem statement. The crop name Li is a string of up to 20 characters consisting of only lowercase letters, and 1 ≤ Pi, Ai, Bi, Ci, Di, Ei, Fi, Si ≤ 100, 1 ≤ Mi ≤ 5. It can be assumed that no crop has the same name in one case.
The end of the input is represented by a line containing only one zero.
Output
For each dataset, output the crop names, one for each row, in descending order of income efficiency. For crops with the same income efficiency, output their names in ascending dictionary order.
After the output of each data set, output one line consisting of only "#".
Example
Input
5
apple 1 1 1 1 1 1 1 10 1
banana 1 2 2 2 2 2 1 10 1
carrot 1 2 2 2 2 2 1 10 2
durian 1 3 3 3 3 3 1 10 1
eggplant 1 3 3 3 3 3 1 100 1
4
enoki 1 3 3 3 3 3 1 10 1
tomato 1 3 3 3 3 3 1 10 1
potato 1 3 3 3 3 3 1 10 1
onion 1 3 3 3 3 3 1 10 1
3
a 10 1 1 1 1 1 1 10 1
b 10 2 2 2 2 2 2 10 1
c 10 2 2 2 2 2 2 10 1
0
Output
eggplant
apple
carrot
banana
durian
#
enoki
onion
potato
tomato
#
b
c
a
#
Submitted Solution:
```
while True:
N = int(input())
ans = []
if N == 0:
break
for i in range(N):
L,P,A,B,C,D,E,F,S,M = input().split()
P = int(P)
A = int(A)
B = int(B)
C = int(C)
D = int(D)
E = int(E)
F = int(F)
S = int(S)
M = int(M)
time = A+B+C+(D+E)*M
mon = S * M * F - P
ans.append([-1 * (mon/time),L])
ans.sort()
for i in range(N):
print (ans[i][1])
print ("#")
``` | instruction | 0 | 16,788 | 3 | 33,576 |
Yes | output | 1 | 16,788 | 3 | 33,577 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
You are enthusiastic about the popular web game "Moonlight Ranch". The purpose of this game is to grow crops in the fields, sell them to earn income, and use that income to grow the ranch.
You wanted to grow the field quickly. Therefore, we decided to arrange the crops that can be grown in the game based on the income efficiency per hour.
You have to buy seeds to grow crops. Here, the name of the species of crop i is given by Li, and the price is given by Pi. When seeds are planted in the field, they sprout after time Ai. Young leaves appear 2 hours after the buds emerge. The leaves grow thick after Ci. The flowers bloom 10 hours after the leaves grow. Fruits come out time Ei after the flowers bloom. One seed produces Fi fruits, each of which sells at the price of Si. Some crops are multi-stage crops and bear a total of Mi fruit. In the case of a single-stage crop, it is represented by Mi = 1. Multi-season crops return to leaves after fruiting until the Mith fruit. The income for a seed is the amount of money sold for all the fruits of that seed minus the price of the seed. In addition, the income efficiency of the seed is the value obtained by dividing the income by the time from planting the seed to the completion of all the fruits.
Your job is to write a program that sorts and outputs crop information given as input, sorted in descending order of income efficiency.
Input
The input is a sequence of datasets, and each dataset is given in the following format.
> N
> L1 P1 A1 B1 C1 D1 E1 F1 S1 M1
> L2 P2 A2 B2 C2 D2 E2 F2 S2 M2
> ...
> LN PN AN BN CN DN EN FN SN MN
>
The first line is the number of crops N in the dataset (1 ≤ N ≤ 50).
The N lines that follow contain information about one crop in each line. The meaning of each variable is as described in the problem statement. The crop name Li is a string of up to 20 characters consisting of only lowercase letters, and 1 ≤ Pi, Ai, Bi, Ci, Di, Ei, Fi, Si ≤ 100, 1 ≤ Mi ≤ 5. It can be assumed that no crop has the same name in one case.
The end of the input is represented by a line containing only one zero.
Output
For each dataset, output the crop names, one for each row, in descending order of income efficiency. For crops with the same income efficiency, output their names in ascending dictionary order.
After the output of each data set, output one line consisting of only "#".
Example
Input
5
apple 1 1 1 1 1 1 1 10 1
banana 1 2 2 2 2 2 1 10 1
carrot 1 2 2 2 2 2 1 10 2
durian 1 3 3 3 3 3 1 10 1
eggplant 1 3 3 3 3 3 1 100 1
4
enoki 1 3 3 3 3 3 1 10 1
tomato 1 3 3 3 3 3 1 10 1
potato 1 3 3 3 3 3 1 10 1
onion 1 3 3 3 3 3 1 10 1
3
a 10 1 1 1 1 1 1 10 1
b 10 2 2 2 2 2 2 10 1
c 10 2 2 2 2 2 2 10 1
0
Output
eggplant
apple
carrot
banana
durian
#
enoki
onion
potato
tomato
#
b
c
a
#
Submitted Solution:
```
while True:
amount = int(input())
if amount == 0:
break
efficiency_list = []
for _ in range(amount):
crop = input().split()
time = sum(map(int, crop[2:7]))
M = int(crop[9])
if M > 1:
for _ in range(1, M):
time += int(crop[5]) + int(crop[6])
fruits = M * int(crop[7])
efficiency = (fruits * int(crop[8]) - int(crop[1])) / time
efficiency_list.append((crop[0], efficiency))
efficiency_list.sort(key=lambda x:(-x[1], x[0]))
for element in efficiency_list:
print(element[0])
print("#")
``` | instruction | 0 | 16,789 | 3 | 33,578 |
Yes | output | 1 | 16,789 | 3 | 33,579 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
You are enthusiastic about the popular web game "Moonlight Ranch". The purpose of this game is to grow crops in the fields, sell them to earn income, and use that income to grow the ranch.
You wanted to grow the field quickly. Therefore, we decided to arrange the crops that can be grown in the game based on the income efficiency per hour.
You have to buy seeds to grow crops. Here, the name of the species of crop i is given by Li, and the price is given by Pi. When seeds are planted in the field, they sprout after time Ai. Young leaves appear 2 hours after the buds emerge. The leaves grow thick after Ci. The flowers bloom 10 hours after the leaves grow. Fruits come out time Ei after the flowers bloom. One seed produces Fi fruits, each of which sells at the price of Si. Some crops are multi-stage crops and bear a total of Mi fruit. In the case of a single-stage crop, it is represented by Mi = 1. Multi-season crops return to leaves after fruiting until the Mith fruit. The income for a seed is the amount of money sold for all the fruits of that seed minus the price of the seed. In addition, the income efficiency of the seed is the value obtained by dividing the income by the time from planting the seed to the completion of all the fruits.
Your job is to write a program that sorts and outputs crop information given as input, sorted in descending order of income efficiency.
Input
The input is a sequence of datasets, and each dataset is given in the following format.
> N
> L1 P1 A1 B1 C1 D1 E1 F1 S1 M1
> L2 P2 A2 B2 C2 D2 E2 F2 S2 M2
> ...
> LN PN AN BN CN DN EN FN SN MN
>
The first line is the number of crops N in the dataset (1 ≤ N ≤ 50).
The N lines that follow contain information about one crop in each line. The meaning of each variable is as described in the problem statement. The crop name Li is a string of up to 20 characters consisting of only lowercase letters, and 1 ≤ Pi, Ai, Bi, Ci, Di, Ei, Fi, Si ≤ 100, 1 ≤ Mi ≤ 5. It can be assumed that no crop has the same name in one case.
The end of the input is represented by a line containing only one zero.
Output
For each dataset, output the crop names, one for each row, in descending order of income efficiency. For crops with the same income efficiency, output their names in ascending dictionary order.
After the output of each data set, output one line consisting of only "#".
Example
Input
5
apple 1 1 1 1 1 1 1 10 1
banana 1 2 2 2 2 2 1 10 1
carrot 1 2 2 2 2 2 1 10 2
durian 1 3 3 3 3 3 1 10 1
eggplant 1 3 3 3 3 3 1 100 1
4
enoki 1 3 3 3 3 3 1 10 1
tomato 1 3 3 3 3 3 1 10 1
potato 1 3 3 3 3 3 1 10 1
onion 1 3 3 3 3 3 1 10 1
3
a 10 1 1 1 1 1 1 10 1
b 10 2 2 2 2 2 2 10 1
c 10 2 2 2 2 2 2 10 1
0
Output
eggplant
apple
carrot
banana
durian
#
enoki
onion
potato
tomato
#
b
c
a
#
Submitted Solution:
```
while True:
n=int(input())
if n==0:
exit()
else:
aa=[]
for i in range(n):
l,p,a,b,c,d,e,f,s,m=input().split()
p=int(p)
a=int(a)
b=int(b)
c=int(c)
d=int(d)
e=int(e)
f=int(f)
s=int(s)
m=int(m)
time=a+b+c+(d+e)*m
pro=s*m*f-p
aa.append([pro/time,l])
aa.sort(key=lambda x:(-x[0],x[1]))
for i in range(n):
print(aa[i][1])
print("#")
``` | instruction | 0 | 16,790 | 3 | 33,580 |
Yes | output | 1 | 16,790 | 3 | 33,581 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
You are enthusiastic about the popular web game "Moonlight Ranch". The purpose of this game is to grow crops in the fields, sell them to earn income, and use that income to grow the ranch.
You wanted to grow the field quickly. Therefore, we decided to arrange the crops that can be grown in the game based on the income efficiency per hour.
You have to buy seeds to grow crops. Here, the name of the species of crop i is given by Li, and the price is given by Pi. When seeds are planted in the field, they sprout after time Ai. Young leaves appear 2 hours after the buds emerge. The leaves grow thick after Ci. The flowers bloom 10 hours after the leaves grow. Fruits come out time Ei after the flowers bloom. One seed produces Fi fruits, each of which sells at the price of Si. Some crops are multi-stage crops and bear a total of Mi fruit. In the case of a single-stage crop, it is represented by Mi = 1. Multi-season crops return to leaves after fruiting until the Mith fruit. The income for a seed is the amount of money sold for all the fruits of that seed minus the price of the seed. In addition, the income efficiency of the seed is the value obtained by dividing the income by the time from planting the seed to the completion of all the fruits.
Your job is to write a program that sorts and outputs crop information given as input, sorted in descending order of income efficiency.
Input
The input is a sequence of datasets, and each dataset is given in the following format.
> N
> L1 P1 A1 B1 C1 D1 E1 F1 S1 M1
> L2 P2 A2 B2 C2 D2 E2 F2 S2 M2
> ...
> LN PN AN BN CN DN EN FN SN MN
>
The first line is the number of crops N in the dataset (1 ≤ N ≤ 50).
The N lines that follow contain information about one crop in each line. The meaning of each variable is as described in the problem statement. The crop name Li is a string of up to 20 characters consisting of only lowercase letters, and 1 ≤ Pi, Ai, Bi, Ci, Di, Ei, Fi, Si ≤ 100, 1 ≤ Mi ≤ 5. It can be assumed that no crop has the same name in one case.
The end of the input is represented by a line containing only one zero.
Output
For each dataset, output the crop names, one for each row, in descending order of income efficiency. For crops with the same income efficiency, output their names in ascending dictionary order.
After the output of each data set, output one line consisting of only "#".
Example
Input
5
apple 1 1 1 1 1 1 1 10 1
banana 1 2 2 2 2 2 1 10 1
carrot 1 2 2 2 2 2 1 10 2
durian 1 3 3 3 3 3 1 10 1
eggplant 1 3 3 3 3 3 1 100 1
4
enoki 1 3 3 3 3 3 1 10 1
tomato 1 3 3 3 3 3 1 10 1
potato 1 3 3 3 3 3 1 10 1
onion 1 3 3 3 3 3 1 10 1
3
a 10 1 1 1 1 1 1 10 1
b 10 2 2 2 2 2 2 10 1
c 10 2 2 2 2 2 2 10 1
0
Output
eggplant
apple
carrot
banana
durian
#
enoki
onion
potato
tomato
#
b
c
a
#
Submitted Solution:
```
#!usr/bin/env python3
from collections import defaultdict,deque
from heapq import heappush, heappop
import sys
import math
import bisect
import random
def LI(): return [int(x) for x in sys.stdin.readline().split()]
def I(): return int(sys.stdin.readline())
def LS():return [list(x) for x in sys.stdin.readline().split()]
def S(): return list(sys.stdin.readline())[:-1]
def IR(n):
return [I() for i in range(n)]
def LIR(n):
return [LI() for i in range(n)]
def SR(n):
return [S() for i in range(n)]
def LSR(n):
return [LS() for i in range(n)]
sys.setrecursionlimit(1000000)
mod = 1000000007
def solve(n):
lis = []
for i in range(n):
l = input().split()
p,a,b,c,d,e,f,s,m = [int(i) for i in l[1:]]
l = l[0]
lis.append(((f*s*m-p)/(a+b+c+(d+e)*m),l))
lis.sort(key = lambda x:(-x[0],x[1]))
for i, j in lis:
print(j)
print("#")
return
#Solve
if __name__ == "__main__":
while 1:
n = I()
if n == 0:
break
solve(n)
``` | instruction | 0 | 16,791 | 3 | 33,582 |
Yes | output | 1 | 16,791 | 3 | 33,583 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
You are enthusiastic about the popular web game "Moonlight Ranch". The purpose of this game is to grow crops in the fields, sell them to earn income, and use that income to grow the ranch.
You wanted to grow the field quickly. Therefore, we decided to arrange the crops that can be grown in the game based on the income efficiency per hour.
You have to buy seeds to grow crops. Here, the name of the species of crop i is given by Li, and the price is given by Pi. When seeds are planted in the field, they sprout after time Ai. Young leaves appear 2 hours after the buds emerge. The leaves grow thick after Ci. The flowers bloom 10 hours after the leaves grow. Fruits come out time Ei after the flowers bloom. One seed produces Fi fruits, each of which sells at the price of Si. Some crops are multi-stage crops and bear a total of Mi fruit. In the case of a single-stage crop, it is represented by Mi = 1. Multi-season crops return to leaves after fruiting until the Mith fruit. The income for a seed is the amount of money sold for all the fruits of that seed minus the price of the seed. In addition, the income efficiency of the seed is the value obtained by dividing the income by the time from planting the seed to the completion of all the fruits.
Your job is to write a program that sorts and outputs crop information given as input, sorted in descending order of income efficiency.
Input
The input is a sequence of datasets, and each dataset is given in the following format.
> N
> L1 P1 A1 B1 C1 D1 E1 F1 S1 M1
> L2 P2 A2 B2 C2 D2 E2 F2 S2 M2
> ...
> LN PN AN BN CN DN EN FN SN MN
>
The first line is the number of crops N in the dataset (1 ≤ N ≤ 50).
The N lines that follow contain information about one crop in each line. The meaning of each variable is as described in the problem statement. The crop name Li is a string of up to 20 characters consisting of only lowercase letters, and 1 ≤ Pi, Ai, Bi, Ci, Di, Ei, Fi, Si ≤ 100, 1 ≤ Mi ≤ 5. It can be assumed that no crop has the same name in one case.
The end of the input is represented by a line containing only one zero.
Output
For each dataset, output the crop names, one for each row, in descending order of income efficiency. For crops with the same income efficiency, output their names in ascending dictionary order.
After the output of each data set, output one line consisting of only "#".
Example
Input
5
apple 1 1 1 1 1 1 1 10 1
banana 1 2 2 2 2 2 1 10 1
carrot 1 2 2 2 2 2 1 10 2
durian 1 3 3 3 3 3 1 10 1
eggplant 1 3 3 3 3 3 1 100 1
4
enoki 1 3 3 3 3 3 1 10 1
tomato 1 3 3 3 3 3 1 10 1
potato 1 3 3 3 3 3 1 10 1
onion 1 3 3 3 3 3 1 10 1
3
a 10 1 1 1 1 1 1 10 1
b 10 2 2 2 2 2 2 10 1
c 10 2 2 2 2 2 2 10 1
0
Output
eggplant
apple
carrot
banana
durian
#
enoki
onion
potato
tomato
#
b
c
a
#
Submitted Solution:
```
while True:
amount = int(input())
if amount == 0:
break
efficiency_list = []
for _ in range(amount):
crop = input().split()
time = sum(map(int, crop[2:7]))
M = int(crop[9])
if M > 1:
for _ in range(1, M):
time += int(crop[5]) + int(crop[6])
fruits = M * int(crop[7])
efficiency = (fruits * int(crop[8]) - int(crop[1])) / time
efficiency_list.append(tuple([crop[0], efficiency]))
print(*efficiency_list)
efficiency_list.sort(key=lambda x:(-x[1], x[0]))
for element in efficiency_list:
print(element[0])
print("#")
``` | instruction | 0 | 16,792 | 3 | 33,584 |
No | output | 1 | 16,792 | 3 | 33,585 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
You are enthusiastic about the popular web game "Moonlight Ranch". The purpose of this game is to grow crops in the fields, sell them to earn income, and use that income to grow the ranch.
You wanted to grow the field quickly. Therefore, we decided to arrange the crops that can be grown in the game based on the income efficiency per hour.
You have to buy seeds to grow crops. Here, the name of the species of crop i is given by Li, and the price is given by Pi. When seeds are planted in the field, they sprout after time Ai. Young leaves appear 2 hours after the buds emerge. The leaves grow thick after Ci. The flowers bloom 10 hours after the leaves grow. Fruits come out time Ei after the flowers bloom. One seed produces Fi fruits, each of which sells at the price of Si. Some crops are multi-stage crops and bear a total of Mi fruit. In the case of a single-stage crop, it is represented by Mi = 1. Multi-season crops return to leaves after fruiting until the Mith fruit. The income for a seed is the amount of money sold for all the fruits of that seed minus the price of the seed. In addition, the income efficiency of the seed is the value obtained by dividing the income by the time from planting the seed to the completion of all the fruits.
Your job is to write a program that sorts and outputs crop information given as input, sorted in descending order of income efficiency.
Input
The input is a sequence of datasets, and each dataset is given in the following format.
> N
> L1 P1 A1 B1 C1 D1 E1 F1 S1 M1
> L2 P2 A2 B2 C2 D2 E2 F2 S2 M2
> ...
> LN PN AN BN CN DN EN FN SN MN
>
The first line is the number of crops N in the dataset (1 ≤ N ≤ 50).
The N lines that follow contain information about one crop in each line. The meaning of each variable is as described in the problem statement. The crop name Li is a string of up to 20 characters consisting of only lowercase letters, and 1 ≤ Pi, Ai, Bi, Ci, Di, Ei, Fi, Si ≤ 100, 1 ≤ Mi ≤ 5. It can be assumed that no crop has the same name in one case.
The end of the input is represented by a line containing only one zero.
Output
For each dataset, output the crop names, one for each row, in descending order of income efficiency. For crops with the same income efficiency, output their names in ascending dictionary order.
After the output of each data set, output one line consisting of only "#".
Example
Input
5
apple 1 1 1 1 1 1 1 10 1
banana 1 2 2 2 2 2 1 10 1
carrot 1 2 2 2 2 2 1 10 2
durian 1 3 3 3 3 3 1 10 1
eggplant 1 3 3 3 3 3 1 100 1
4
enoki 1 3 3 3 3 3 1 10 1
tomato 1 3 3 3 3 3 1 10 1
potato 1 3 3 3 3 3 1 10 1
onion 1 3 3 3 3 3 1 10 1
3
a 10 1 1 1 1 1 1 10 1
b 10 2 2 2 2 2 2 10 1
c 10 2 2 2 2 2 2 10 1
0
Output
eggplant
apple
carrot
banana
durian
#
enoki
onion
potato
tomato
#
b
c
a
#
Submitted Solution:
```
import numpy as np
import sys
def firster(former, latter):
com = [str(former), str(latter)]
com.sort()
#print(former)
#print(latter)
#print(com)
if com[0] == former:
return 1
return 0
def one_turn(N):
effs = [] #name
effs_val = {} #value
for i in range(N):
data = input().split()
period = 0
name = data[0]
p = int(data[1])
period = int(data[2])+int(data[3])+int(data[4])+int(data[5])+int(data[6])
f = int(data[7])
s = int(data[8])
m = int(data[9])
eff = (m*f*s-p)/(period+(m-1)*(int(data[5])+int(data[6])))
effs_val[name] = eff
if i == 0:
effs.insert(0,name)
continue
for k in range(i):
if effs_val[effs[k]] < eff:
effs.insert(k,name)
break
elif (effs_val[effs[k]] == eff and firster(name,effs[k])):
effs.insert(k,name)
break
elif k == i-1:
effs.append(name)
#print(effs)
for l in range(N):
print(effs[l])
#print(effs_val[effs[l]])
N = int(sys.stdin.readline())
while N > 0:
one_turn(N)
print('#')
N = int(sys.stdin.readline())
print('#')
``` | instruction | 0 | 16,793 | 3 | 33,586 |
No | output | 1 | 16,793 | 3 | 33,587 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
You are enthusiastic about the popular web game "Moonlight Ranch". The purpose of this game is to grow crops in the fields, sell them to earn income, and use that income to grow the ranch.
You wanted to grow the field quickly. Therefore, we decided to arrange the crops that can be grown in the game based on the income efficiency per hour.
You have to buy seeds to grow crops. Here, the name of the species of crop i is given by Li, and the price is given by Pi. When seeds are planted in the field, they sprout after time Ai. Young leaves appear 2 hours after the buds emerge. The leaves grow thick after Ci. The flowers bloom 10 hours after the leaves grow. Fruits come out time Ei after the flowers bloom. One seed produces Fi fruits, each of which sells at the price of Si. Some crops are multi-stage crops and bear a total of Mi fruit. In the case of a single-stage crop, it is represented by Mi = 1. Multi-season crops return to leaves after fruiting until the Mith fruit. The income for a seed is the amount of money sold for all the fruits of that seed minus the price of the seed. In addition, the income efficiency of the seed is the value obtained by dividing the income by the time from planting the seed to the completion of all the fruits.
Your job is to write a program that sorts and outputs crop information given as input, sorted in descending order of income efficiency.
Input
The input is a sequence of datasets, and each dataset is given in the following format.
> N
> L1 P1 A1 B1 C1 D1 E1 F1 S1 M1
> L2 P2 A2 B2 C2 D2 E2 F2 S2 M2
> ...
> LN PN AN BN CN DN EN FN SN MN
>
The first line is the number of crops N in the dataset (1 ≤ N ≤ 50).
The N lines that follow contain information about one crop in each line. The meaning of each variable is as described in the problem statement. The crop name Li is a string of up to 20 characters consisting of only lowercase letters, and 1 ≤ Pi, Ai, Bi, Ci, Di, Ei, Fi, Si ≤ 100, 1 ≤ Mi ≤ 5. It can be assumed that no crop has the same name in one case.
The end of the input is represented by a line containing only one zero.
Output
For each dataset, output the crop names, one for each row, in descending order of income efficiency. For crops with the same income efficiency, output their names in ascending dictionary order.
After the output of each data set, output one line consisting of only "#".
Example
Input
5
apple 1 1 1 1 1 1 1 10 1
banana 1 2 2 2 2 2 1 10 1
carrot 1 2 2 2 2 2 1 10 2
durian 1 3 3 3 3 3 1 10 1
eggplant 1 3 3 3 3 3 1 100 1
4
enoki 1 3 3 3 3 3 1 10 1
tomato 1 3 3 3 3 3 1 10 1
potato 1 3 3 3 3 3 1 10 1
onion 1 3 3 3 3 3 1 10 1
3
a 10 1 1 1 1 1 1 10 1
b 10 2 2 2 2 2 2 10 1
c 10 2 2 2 2 2 2 10 1
0
Output
eggplant
apple
carrot
banana
durian
#
enoki
onion
potato
tomato
#
b
c
a
#
Submitted Solution:
```
resultss = []
while True:
N = int(input())
if N == 0:
break
B = [list(map(str, input().split())) for _ in range(N)]
results = []
for i in range(N):
A = []
name = B[i][0]
B[i][0] = B[i][1]
for j in range(10):
A.append(int(B[i][j]))
if A[-1] == 1:
time = A[2] + A[3] + A[4] + A[5] + A[6]
money = A[7] * A[8]
res = money - A[1]
res /= time
else:
time = A[2] + A[3] + A[4] + A[5] + A[6] + (A[5] + A[6]) * (A[-1] - 1)
money = A[7] * A[8] * A[-1]
res = money - A[1]
res /= time
results.append([res, name])
results.sort()
for i in range(len(results)-1):
if results[i][0] == results[i+1][0]:
tmp = results[i+1][1]
results[i+1][1] = results[i][1]
results[i][1] = tmp
resultss.append(results)
for i in range(len(resultss)):
for j in range(len(resultss[i])):
print(resultss[i][-j-1][1])
print('#')
``` | instruction | 0 | 16,794 | 3 | 33,588 |
No | output | 1 | 16,794 | 3 | 33,589 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
You are enthusiastic about the popular web game "Moonlight Ranch". The purpose of this game is to grow crops in the fields, sell them to earn income, and use that income to grow the ranch.
You wanted to grow the field quickly. Therefore, we decided to arrange the crops that can be grown in the game based on the income efficiency per hour.
You have to buy seeds to grow crops. Here, the name of the species of crop i is given by Li, and the price is given by Pi. When seeds are planted in the field, they sprout after time Ai. Young leaves appear 2 hours after the buds emerge. The leaves grow thick after Ci. The flowers bloom 10 hours after the leaves grow. Fruits come out time Ei after the flowers bloom. One seed produces Fi fruits, each of which sells at the price of Si. Some crops are multi-stage crops and bear a total of Mi fruit. In the case of a single-stage crop, it is represented by Mi = 1. Multi-season crops return to leaves after fruiting until the Mith fruit. The income for a seed is the amount of money sold for all the fruits of that seed minus the price of the seed. In addition, the income efficiency of the seed is the value obtained by dividing the income by the time from planting the seed to the completion of all the fruits.
Your job is to write a program that sorts and outputs crop information given as input, sorted in descending order of income efficiency.
Input
The input is a sequence of datasets, and each dataset is given in the following format.
> N
> L1 P1 A1 B1 C1 D1 E1 F1 S1 M1
> L2 P2 A2 B2 C2 D2 E2 F2 S2 M2
> ...
> LN PN AN BN CN DN EN FN SN MN
>
The first line is the number of crops N in the dataset (1 ≤ N ≤ 50).
The N lines that follow contain information about one crop in each line. The meaning of each variable is as described in the problem statement. The crop name Li is a string of up to 20 characters consisting of only lowercase letters, and 1 ≤ Pi, Ai, Bi, Ci, Di, Ei, Fi, Si ≤ 100, 1 ≤ Mi ≤ 5. It can be assumed that no crop has the same name in one case.
The end of the input is represented by a line containing only one zero.
Output
For each dataset, output the crop names, one for each row, in descending order of income efficiency. For crops with the same income efficiency, output their names in ascending dictionary order.
After the output of each data set, output one line consisting of only "#".
Example
Input
5
apple 1 1 1 1 1 1 1 10 1
banana 1 2 2 2 2 2 1 10 1
carrot 1 2 2 2 2 2 1 10 2
durian 1 3 3 3 3 3 1 10 1
eggplant 1 3 3 3 3 3 1 100 1
4
enoki 1 3 3 3 3 3 1 10 1
tomato 1 3 3 3 3 3 1 10 1
potato 1 3 3 3 3 3 1 10 1
onion 1 3 3 3 3 3 1 10 1
3
a 10 1 1 1 1 1 1 10 1
b 10 2 2 2 2 2 2 10 1
c 10 2 2 2 2 2 2 10 1
0
Output
eggplant
apple
carrot
banana
durian
#
enoki
onion
potato
tomato
#
b
c
a
#
Submitted Solution:
```
resultss = []
while True:
N = int(input())
if N == 0:
break
B = [list(map(str, input().split())) for _ in range(N)]
results = []
for i in range(N):
A = []
name = B[i][0]
B[i][0] = B[i][1]
for j in range(10):
A.append(int(B[i][j]))
if A[-1] == 1:
time = A[2] + A[3] + A[4] + A[5] + A[6]
money = A[7] * A[8]
res = money - A[1]
res /= time
else:
time = A[2] + A[3] + A[4] + A[5] + A[6] + (A[5] + A[6]) * (A[-1] - 1)
money = A[7] * A[8] * A[-1]
res = money - A[1]
res /= time
results.append([res, name])
tmp = results[0][0]
flag =False
for i in range(len(results)):
if results[i][0] != tmp:
flag = True
if flag:
results.sort()
else:
results = sorted(results, key=lambda x: x[1], reverse=True)
resultss.append(results)
for i in range(len(resultss)):
for j in range(len(resultss[i])):
print(resultss[i][-j-1][1])
print('#')
``` | instruction | 0 | 16,795 | 3 | 33,590 |
No | output | 1 | 16,795 | 3 | 33,591 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
Mad scientist Mike entertains himself by arranging rows of dominoes. He doesn't need dominoes, though: he uses rectangular magnets instead. Each magnet has two poles, positive (a "plus") and negative (a "minus"). If two magnets are put together at a close distance, then the like poles will repel each other and the opposite poles will attract each other.
Mike starts by laying one magnet horizontally on the table. During each following step Mike adds one more magnet horizontally to the right end of the row. Depending on how Mike puts the magnet on the table, it is either attracted to the previous one (forming a group of multiple magnets linked together) or repelled by it (then Mike lays this magnet at some distance to the right from the previous one). We assume that a sole magnet not linked to others forms a group of its own.
<image>
Mike arranged multiple magnets in a row. Determine the number of groups that the magnets formed.
Input
The first line of the input contains an integer n (1 ≤ n ≤ 100000) — the number of magnets. Then n lines follow. The i-th line (1 ≤ i ≤ n) contains either characters "01", if Mike put the i-th magnet in the "plus-minus" position, or characters "10", if Mike put the magnet in the "minus-plus" position.
Output
On the single line of the output print the number of groups of magnets.
Examples
Input
6
10
10
10
01
10
10
Output
3
Input
4
01
01
10
10
Output
2
Note
The first testcase corresponds to the figure. The testcase has three groups consisting of three, one and two magnets.
The second testcase has two groups, each consisting of two magnets.
Submitted Solution:
```
n,m=int(input()),1
x=[]
for i in range(0,n):
x.append(input())
for i in range(len(x)-1):
m1=x[i]
m2=x[i+1]
if m1[1] ==m2[0]:
m+=1
print(m)
``` | instruction | 0 | 17,135 | 3 | 34,270 |
Yes | output | 1 | 17,135 | 3 | 34,271 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
Mad scientist Mike entertains himself by arranging rows of dominoes. He doesn't need dominoes, though: he uses rectangular magnets instead. Each magnet has two poles, positive (a "plus") and negative (a "minus"). If two magnets are put together at a close distance, then the like poles will repel each other and the opposite poles will attract each other.
Mike starts by laying one magnet horizontally on the table. During each following step Mike adds one more magnet horizontally to the right end of the row. Depending on how Mike puts the magnet on the table, it is either attracted to the previous one (forming a group of multiple magnets linked together) or repelled by it (then Mike lays this magnet at some distance to the right from the previous one). We assume that a sole magnet not linked to others forms a group of its own.
<image>
Mike arranged multiple magnets in a row. Determine the number of groups that the magnets formed.
Input
The first line of the input contains an integer n (1 ≤ n ≤ 100000) — the number of magnets. Then n lines follow. The i-th line (1 ≤ i ≤ n) contains either characters "01", if Mike put the i-th magnet in the "plus-minus" position, or characters "10", if Mike put the magnet in the "minus-plus" position.
Output
On the single line of the output print the number of groups of magnets.
Examples
Input
6
10
10
10
01
10
10
Output
3
Input
4
01
01
10
10
Output
2
Note
The first testcase corresponds to the figure. The testcase has three groups consisting of three, one and two magnets.
The second testcase has two groups, each consisting of two magnets.
Submitted Solution:
```
n = int(input())
islands = 1
x = str(input())
before = x[1]
for a in range(n-1):
magnet = str(input())
if magnet[0] == before:
islands += 1
before = magnet[1]
print(islands)
``` | instruction | 0 | 17,136 | 3 | 34,272 |
Yes | output | 1 | 17,136 | 3 | 34,273 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
Mad scientist Mike entertains himself by arranging rows of dominoes. He doesn't need dominoes, though: he uses rectangular magnets instead. Each magnet has two poles, positive (a "plus") and negative (a "minus"). If two magnets are put together at a close distance, then the like poles will repel each other and the opposite poles will attract each other.
Mike starts by laying one magnet horizontally on the table. During each following step Mike adds one more magnet horizontally to the right end of the row. Depending on how Mike puts the magnet on the table, it is either attracted to the previous one (forming a group of multiple magnets linked together) or repelled by it (then Mike lays this magnet at some distance to the right from the previous one). We assume that a sole magnet not linked to others forms a group of its own.
<image>
Mike arranged multiple magnets in a row. Determine the number of groups that the magnets formed.
Input
The first line of the input contains an integer n (1 ≤ n ≤ 100000) — the number of magnets. Then n lines follow. The i-th line (1 ≤ i ≤ n) contains either characters "01", if Mike put the i-th magnet in the "plus-minus" position, or characters "10", if Mike put the magnet in the "minus-plus" position.
Output
On the single line of the output print the number of groups of magnets.
Examples
Input
6
10
10
10
01
10
10
Output
3
Input
4
01
01
10
10
Output
2
Note
The first testcase corresponds to the figure. The testcase has three groups consisting of three, one and two magnets.
The second testcase has two groups, each consisting of two magnets.
Submitted Solution:
```
n=int(input())
count=1
check=0
for i in range(n):
s=input()
if check!=s:
count+=1
check=s
print(count)
``` | instruction | 0 | 17,140 | 3 | 34,280 |
No | output | 1 | 17,140 | 3 | 34,281 |
Provide tags and a correct Python 3 solution for this coding contest problem.
Friends are going to play console. They have two joysticks and only one charger for them. Initially first joystick is charged at a1 percent and second one is charged at a2 percent. You can connect charger to a joystick only at the beginning of each minute. In one minute joystick either discharges by 2 percent (if not connected to a charger) or charges by 1 percent (if connected to a charger).
Game continues while both joysticks have a positive charge. Hence, if at the beginning of minute some joystick is charged by 1 percent, it has to be connected to a charger, otherwise the game stops. If some joystick completely discharges (its charge turns to 0), the game also stops.
Determine the maximum number of minutes that game can last. It is prohibited to pause the game, i. e. at each moment both joysticks should be enabled. It is allowed for joystick to be charged by more than 100 percent.
Input
The first line of the input contains two positive integers a1 and a2 (1 ≤ a1, a2 ≤ 100), the initial charge level of first and second joystick respectively.
Output
Output the only integer, the maximum number of minutes that the game can last. Game continues until some joystick is discharged.
Examples
Input
3 5
Output
6
Input
4 4
Output
5
Note
In the first sample game lasts for 6 minute by using the following algorithm:
* at the beginning of the first minute connect first joystick to the charger, by the end of this minute first joystick is at 4%, second is at 3%;
* continue the game without changing charger, by the end of the second minute the first joystick is at 5%, second is at 1%;
* at the beginning of the third minute connect second joystick to the charger, after this minute the first joystick is at 3%, the second one is at 2%;
* continue the game without changing charger, by the end of the fourth minute first joystick is at 1%, second one is at 3%;
* at the beginning of the fifth minute connect first joystick to the charger, after this minute the first joystick is at 2%, the second one is at 1%;
* at the beginning of the sixth minute connect second joystick to the charger, after this minute the first joystick is at 0%, the second one is at 2%.
After that the first joystick is completely discharged and the game is stopped. | instruction | 0 | 17,258 | 3 | 34,516 |
Tags: dp, greedy, implementation, math
Correct Solution:
```
def maxMin(a,b):
dp = [[0]*(101)]*(101)
#'''
#print("#######" + str(a)+ str(b))
if(a==0 or b == 0):
return 0
if(a==1 and b==1):
return 0
if(a==1 and b>1):
return(1+maxMin(a+1,b-2))
if(a>1 and b==1):
return(1+maxMin(a-2,b+1))
if(b>a):
a,b=b,a
return(1+maxMin(a-2,b+1))
#'''
'''
for i in range(1,101):
dp[i][i]= 2*i-1
for i in range(2,101):
dp[1][i]=1+dp[2][i-2]
return(dp[a-1][b-1])
'''
a,b=map(int,input().split())
ans=maxMin(a,b)
print(ans)
``` | output | 1 | 17,258 | 3 | 34,517 |
Provide tags and a correct Python 3 solution for this coding contest problem.
Friends are going to play console. They have two joysticks and only one charger for them. Initially first joystick is charged at a1 percent and second one is charged at a2 percent. You can connect charger to a joystick only at the beginning of each minute. In one minute joystick either discharges by 2 percent (if not connected to a charger) or charges by 1 percent (if connected to a charger).
Game continues while both joysticks have a positive charge. Hence, if at the beginning of minute some joystick is charged by 1 percent, it has to be connected to a charger, otherwise the game stops. If some joystick completely discharges (its charge turns to 0), the game also stops.
Determine the maximum number of minutes that game can last. It is prohibited to pause the game, i. e. at each moment both joysticks should be enabled. It is allowed for joystick to be charged by more than 100 percent.
Input
The first line of the input contains two positive integers a1 and a2 (1 ≤ a1, a2 ≤ 100), the initial charge level of first and second joystick respectively.
Output
Output the only integer, the maximum number of minutes that the game can last. Game continues until some joystick is discharged.
Examples
Input
3 5
Output
6
Input
4 4
Output
5
Note
In the first sample game lasts for 6 minute by using the following algorithm:
* at the beginning of the first minute connect first joystick to the charger, by the end of this minute first joystick is at 4%, second is at 3%;
* continue the game without changing charger, by the end of the second minute the first joystick is at 5%, second is at 1%;
* at the beginning of the third minute connect second joystick to the charger, after this minute the first joystick is at 3%, the second one is at 2%;
* continue the game without changing charger, by the end of the fourth minute first joystick is at 1%, second one is at 3%;
* at the beginning of the fifth minute connect first joystick to the charger, after this minute the first joystick is at 2%, the second one is at 1%;
* at the beginning of the sixth minute connect second joystick to the charger, after this minute the first joystick is at 0%, the second one is at 2%.
After that the first joystick is completely discharged and the game is stopped. | instruction | 0 | 17,259 | 3 | 34,518 |
Tags: dp, greedy, implementation, math
Correct Solution:
```
a,b=map(int,input().split())
count=0
while a!=0 or b!=0:
minn=min(a,b)
maxx=max(a,b)
a=minn+1
b=maxx-2
if (a==0 or b==0) and (a>=0 and b>=0):
count+=1
break
elif a<0 or b<0 :break
else:count+=1
print(count)
``` | output | 1 | 17,259 | 3 | 34,519 |
Provide tags and a correct Python 3 solution for this coding contest problem.
Friends are going to play console. They have two joysticks and only one charger for them. Initially first joystick is charged at a1 percent and second one is charged at a2 percent. You can connect charger to a joystick only at the beginning of each minute. In one minute joystick either discharges by 2 percent (if not connected to a charger) or charges by 1 percent (if connected to a charger).
Game continues while both joysticks have a positive charge. Hence, if at the beginning of minute some joystick is charged by 1 percent, it has to be connected to a charger, otherwise the game stops. If some joystick completely discharges (its charge turns to 0), the game also stops.
Determine the maximum number of minutes that game can last. It is prohibited to pause the game, i. e. at each moment both joysticks should be enabled. It is allowed for joystick to be charged by more than 100 percent.
Input
The first line of the input contains two positive integers a1 and a2 (1 ≤ a1, a2 ≤ 100), the initial charge level of first and second joystick respectively.
Output
Output the only integer, the maximum number of minutes that the game can last. Game continues until some joystick is discharged.
Examples
Input
3 5
Output
6
Input
4 4
Output
5
Note
In the first sample game lasts for 6 minute by using the following algorithm:
* at the beginning of the first minute connect first joystick to the charger, by the end of this minute first joystick is at 4%, second is at 3%;
* continue the game without changing charger, by the end of the second minute the first joystick is at 5%, second is at 1%;
* at the beginning of the third minute connect second joystick to the charger, after this minute the first joystick is at 3%, the second one is at 2%;
* continue the game without changing charger, by the end of the fourth minute first joystick is at 1%, second one is at 3%;
* at the beginning of the fifth minute connect first joystick to the charger, after this minute the first joystick is at 2%, the second one is at 1%;
* at the beginning of the sixth minute connect second joystick to the charger, after this minute the first joystick is at 0%, the second one is at 2%.
After that the first joystick is completely discharged and the game is stopped. | instruction | 0 | 17,260 | 3 | 34,520 |
Tags: dp, greedy, implementation, math
Correct Solution:
```
a, b = map(int, input().split())
min_ = 0
while(max(a,b) > 1 and min(a,b) > 0):
min_ += 1
if(a < b):
a += 1
b -= 2
else:
b += 1
a -= 2
print(min_)
``` | output | 1 | 17,260 | 3 | 34,521 |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.