message
stringlengths 2
39.6k
| message_type
stringclasses 2
values | message_id
int64 0
1
| conversation_id
int64 450
109k
| cluster
float64 2
2
| __index_level_0__
int64 900
217k
|
|---|---|---|---|---|---|
Provide tags and a correct Python 3 solution for this coding contest problem.
For some reason in many American cartoons anvils fall from time to time onto heroes' heads. Of course, safes, wardrobes, cruisers, planes fall sometimes too... But anvils do so most of all.
Anvils come in different sizes and shapes. Quite often they get the hero stuck deep in the ground. But have you ever thought who throws anvils from the sky? From what height? We are sure that such questions have never troubled you!
It turns out that throwing an anvil properly is not an easy task at all. Let's describe one of the most popular anvil throwing models.
Let the height p of the potential victim vary in the range [0;a] and the direction of the wind q vary in the range [ - b;b]. p and q could be any real (floating) numbers. Then we can assume that the anvil will fit the toon's head perfectly only if the following equation has at least one real root:
<image>
Determine the probability with which an aim can be successfully hit by an anvil.
You can assume that the p and q coefficients are chosen equiprobably and independently in their ranges.
Input
The first line contains integer t (1 ≤ t ≤ 10000) — amount of testcases.
Each of the following t lines contain two space-separated integers a and b (0 ≤ a, b ≤ 106).
Pretests contain all the tests with 0 < a < 10, 0 ≤ b < 10.
Output
Print t lines — the probability of a successful anvil hit for each testcase. The absolute or relative error of the answer should not exceed 10 - 6.
Examples
Input
2
4 2
1 2
Output
0.6250000000
0.5312500000
|
instruction
| 0
| 104,977
| 2
| 209,954
|
Tags: math, probabilities
Correct Solution:
```
def li():
return list(map(int, input().split(" ")))
for _ in range(int(input())):
a, b=li()
if b != 0 and a != 0:
s = (max(0, a-4*b) + a)/2
s*=min((a/4), b)
ans = 1/2 + s/(2*a*b)
print("{:.8f}".format(ans))
elif b == 0:
print(1)
else:
print(0.5)
```
|
output
| 1
| 104,977
| 2
| 209,955
|
Provide tags and a correct Python 3 solution for this coding contest problem.
For some reason in many American cartoons anvils fall from time to time onto heroes' heads. Of course, safes, wardrobes, cruisers, planes fall sometimes too... But anvils do so most of all.
Anvils come in different sizes and shapes. Quite often they get the hero stuck deep in the ground. But have you ever thought who throws anvils from the sky? From what height? We are sure that such questions have never troubled you!
It turns out that throwing an anvil properly is not an easy task at all. Let's describe one of the most popular anvil throwing models.
Let the height p of the potential victim vary in the range [0;a] and the direction of the wind q vary in the range [ - b;b]. p and q could be any real (floating) numbers. Then we can assume that the anvil will fit the toon's head perfectly only if the following equation has at least one real root:
<image>
Determine the probability with which an aim can be successfully hit by an anvil.
You can assume that the p and q coefficients are chosen equiprobably and independently in their ranges.
Input
The first line contains integer t (1 ≤ t ≤ 10000) — amount of testcases.
Each of the following t lines contain two space-separated integers a and b (0 ≤ a, b ≤ 106).
Pretests contain all the tests with 0 < a < 10, 0 ≤ b < 10.
Output
Print t lines — the probability of a successful anvil hit for each testcase. The absolute or relative error of the answer should not exceed 10 - 6.
Examples
Input
2
4 2
1 2
Output
0.6250000000
0.5312500000
|
instruction
| 0
| 104,978
| 2
| 209,956
|
Tags: math, probabilities
Correct Solution:
```
for i in range(int(input())):
a, b = map(int, input().split(' '))
if b == 0:
print(1)
elif a == 0:
print(1/2)
else:
if 4*b<=a:
print(1-2*b*b/(2*a*b))
else:
print(1-((b+b-a/4)*a/2)/(2*a*b))
```
|
output
| 1
| 104,978
| 2
| 209,957
|
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
For some reason in many American cartoons anvils fall from time to time onto heroes' heads. Of course, safes, wardrobes, cruisers, planes fall sometimes too... But anvils do so most of all.
Anvils come in different sizes and shapes. Quite often they get the hero stuck deep in the ground. But have you ever thought who throws anvils from the sky? From what height? We are sure that such questions have never troubled you!
It turns out that throwing an anvil properly is not an easy task at all. Let's describe one of the most popular anvil throwing models.
Let the height p of the potential victim vary in the range [0;a] and the direction of the wind q vary in the range [ - b;b]. p and q could be any real (floating) numbers. Then we can assume that the anvil will fit the toon's head perfectly only if the following equation has at least one real root:
<image>
Determine the probability with which an aim can be successfully hit by an anvil.
You can assume that the p and q coefficients are chosen equiprobably and independently in their ranges.
Input
The first line contains integer t (1 ≤ t ≤ 10000) — amount of testcases.
Each of the following t lines contain two space-separated integers a and b (0 ≤ a, b ≤ 106).
Pretests contain all the tests with 0 < a < 10, 0 ≤ b < 10.
Output
Print t lines — the probability of a successful anvil hit for each testcase. The absolute or relative error of the answer should not exceed 10 - 6.
Examples
Input
2
4 2
1 2
Output
0.6250000000
0.5312500000
Submitted Solution:
```
def calArea(a, b):
if a <= 4 * b:
return a * min(b, a / 4) / 2
return b * b * 2 + (a - 4 * b) * b
for _ in range(int(input())):
a, b = map(int, input().split())
if b == 0:
print(1)
elif a == 0:
print(0.5)
else:
print("{:.8f}".format(calArea(a, b) / (2 * a * b) + 0.5))
```
|
instruction
| 0
| 104,979
| 2
| 209,958
|
Yes
|
output
| 1
| 104,979
| 2
| 209,959
|
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
For some reason in many American cartoons anvils fall from time to time onto heroes' heads. Of course, safes, wardrobes, cruisers, planes fall sometimes too... But anvils do so most of all.
Anvils come in different sizes and shapes. Quite often they get the hero stuck deep in the ground. But have you ever thought who throws anvils from the sky? From what height? We are sure that such questions have never troubled you!
It turns out that throwing an anvil properly is not an easy task at all. Let's describe one of the most popular anvil throwing models.
Let the height p of the potential victim vary in the range [0;a] and the direction of the wind q vary in the range [ - b;b]. p and q could be any real (floating) numbers. Then we can assume that the anvil will fit the toon's head perfectly only if the following equation has at least one real root:
<image>
Determine the probability with which an aim can be successfully hit by an anvil.
You can assume that the p and q coefficients are chosen equiprobably and independently in their ranges.
Input
The first line contains integer t (1 ≤ t ≤ 10000) — amount of testcases.
Each of the following t lines contain two space-separated integers a and b (0 ≤ a, b ≤ 106).
Pretests contain all the tests with 0 < a < 10, 0 ≤ b < 10.
Output
Print t lines — the probability of a successful anvil hit for each testcase. The absolute or relative error of the answer should not exceed 10 - 6.
Examples
Input
2
4 2
1 2
Output
0.6250000000
0.5312500000
Submitted Solution:
```
c = int(input())
for cases in range(c):
s = input()
s = s.split(' ')
a = int(s[0])
b = int(s[1])
xx = min(a / 4, b)
if b == 0:
print(1.000000000)
if a == 0 and b != 0:
print(0.500000000)
if a != 0 and b != 0:
print("%.9f" % (1.0 / (2 * a * b) * (xx * a - 2 * xx * xx) + 0.5))
```
|
instruction
| 0
| 104,980
| 2
| 209,960
|
Yes
|
output
| 1
| 104,980
| 2
| 209,961
|
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
For some reason in many American cartoons anvils fall from time to time onto heroes' heads. Of course, safes, wardrobes, cruisers, planes fall sometimes too... But anvils do so most of all.
Anvils come in different sizes and shapes. Quite often they get the hero stuck deep in the ground. But have you ever thought who throws anvils from the sky? From what height? We are sure that such questions have never troubled you!
It turns out that throwing an anvil properly is not an easy task at all. Let's describe one of the most popular anvil throwing models.
Let the height p of the potential victim vary in the range [0;a] and the direction of the wind q vary in the range [ - b;b]. p and q could be any real (floating) numbers. Then we can assume that the anvil will fit the toon's head perfectly only if the following equation has at least one real root:
<image>
Determine the probability with which an aim can be successfully hit by an anvil.
You can assume that the p and q coefficients are chosen equiprobably and independently in their ranges.
Input
The first line contains integer t (1 ≤ t ≤ 10000) — amount of testcases.
Each of the following t lines contain two space-separated integers a and b (0 ≤ a, b ≤ 106).
Pretests contain all the tests with 0 < a < 10, 0 ≤ b < 10.
Output
Print t lines — the probability of a successful anvil hit for each testcase. The absolute or relative error of the answer should not exceed 10 - 6.
Examples
Input
2
4 2
1 2
Output
0.6250000000
0.5312500000
Submitted Solution:
```
for i in range(int(input())):
a, b = map(int, input().split())
print(0.5 + a / (b << 4) if 4 * b > a else 1 - b / a if a else 1)
```
|
instruction
| 0
| 104,981
| 2
| 209,962
|
Yes
|
output
| 1
| 104,981
| 2
| 209,963
|
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
For some reason in many American cartoons anvils fall from time to time onto heroes' heads. Of course, safes, wardrobes, cruisers, planes fall sometimes too... But anvils do so most of all.
Anvils come in different sizes and shapes. Quite often they get the hero stuck deep in the ground. But have you ever thought who throws anvils from the sky? From what height? We are sure that such questions have never troubled you!
It turns out that throwing an anvil properly is not an easy task at all. Let's describe one of the most popular anvil throwing models.
Let the height p of the potential victim vary in the range [0;a] and the direction of the wind q vary in the range [ - b;b]. p and q could be any real (floating) numbers. Then we can assume that the anvil will fit the toon's head perfectly only if the following equation has at least one real root:
<image>
Determine the probability with which an aim can be successfully hit by an anvil.
You can assume that the p and q coefficients are chosen equiprobably and independently in their ranges.
Input
The first line contains integer t (1 ≤ t ≤ 10000) — amount of testcases.
Each of the following t lines contain two space-separated integers a and b (0 ≤ a, b ≤ 106).
Pretests contain all the tests with 0 < a < 10, 0 ≤ b < 10.
Output
Print t lines — the probability of a successful anvil hit for each testcase. The absolute or relative error of the answer should not exceed 10 - 6.
Examples
Input
2
4 2
1 2
Output
0.6250000000
0.5312500000
Submitted Solution:
```
for i in range(int(input())):print("%.8f"%(lambda a,b:1 if a==0==b else (a/b/16+1/2)if b>a/4 else(1-b/a))(*list(map(int,input().split()))[0:2]))
```
|
instruction
| 0
| 104,982
| 2
| 209,964
|
Yes
|
output
| 1
| 104,982
| 2
| 209,965
|
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
For some reason in many American cartoons anvils fall from time to time onto heroes' heads. Of course, safes, wardrobes, cruisers, planes fall sometimes too... But anvils do so most of all.
Anvils come in different sizes and shapes. Quite often they get the hero stuck deep in the ground. But have you ever thought who throws anvils from the sky? From what height? We are sure that such questions have never troubled you!
It turns out that throwing an anvil properly is not an easy task at all. Let's describe one of the most popular anvil throwing models.
Let the height p of the potential victim vary in the range [0;a] and the direction of the wind q vary in the range [ - b;b]. p and q could be any real (floating) numbers. Then we can assume that the anvil will fit the toon's head perfectly only if the following equation has at least one real root:
<image>
Determine the probability with which an aim can be successfully hit by an anvil.
You can assume that the p and q coefficients are chosen equiprobably and independently in their ranges.
Input
The first line contains integer t (1 ≤ t ≤ 10000) — amount of testcases.
Each of the following t lines contain two space-separated integers a and b (0 ≤ a, b ≤ 106).
Pretests contain all the tests with 0 < a < 10, 0 ≤ b < 10.
Output
Print t lines — the probability of a successful anvil hit for each testcase. The absolute or relative error of the answer should not exceed 10 - 6.
Examples
Input
2
4 2
1 2
Output
0.6250000000
0.5312500000
Submitted Solution:
```
def li():
return list(map(int, input().split(" ")))
for _ in range(int(input())):
a, b=li()
if b != 0 and b != 0:
s = (max(0, a-4*b) + a)/2
s*=min((a/4), b)
ans = 1/2 + s/(2*a*b)
print("{:.8f}".format(ans), (max(0, a-4*b) + a)/2)
elif b == 0:
print(1)
else:
print(0.5)
```
|
instruction
| 0
| 104,983
| 2
| 209,966
|
No
|
output
| 1
| 104,983
| 2
| 209,967
|
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
For some reason in many American cartoons anvils fall from time to time onto heroes' heads. Of course, safes, wardrobes, cruisers, planes fall sometimes too... But anvils do so most of all.
Anvils come in different sizes and shapes. Quite often they get the hero stuck deep in the ground. But have you ever thought who throws anvils from the sky? From what height? We are sure that such questions have never troubled you!
It turns out that throwing an anvil properly is not an easy task at all. Let's describe one of the most popular anvil throwing models.
Let the height p of the potential victim vary in the range [0;a] and the direction of the wind q vary in the range [ - b;b]. p and q could be any real (floating) numbers. Then we can assume that the anvil will fit the toon's head perfectly only if the following equation has at least one real root:
<image>
Determine the probability with which an aim can be successfully hit by an anvil.
You can assume that the p and q coefficients are chosen equiprobably and independently in their ranges.
Input
The first line contains integer t (1 ≤ t ≤ 10000) — amount of testcases.
Each of the following t lines contain two space-separated integers a and b (0 ≤ a, b ≤ 106).
Pretests contain all the tests with 0 < a < 10, 0 ≤ b < 10.
Output
Print t lines — the probability of a successful anvil hit for each testcase. The absolute or relative error of the answer should not exceed 10 - 6.
Examples
Input
2
4 2
1 2
Output
0.6250000000
0.5312500000
Submitted Solution:
```
t = int(input())
for _ in range(t):
a, b = map(int, input().split())
if a == 0 and b == 0:
print(1)
elif a == 0:
print(0.5)
elif b == 0:
print(1)
elif a > 4 * b:
print('%.10f' % ((a - 4 * b) / a + 0.5 + b / a))
else:
print('%.10f' % (a / 16 / b + 0.5))
```
|
instruction
| 0
| 104,984
| 2
| 209,968
|
No
|
output
| 1
| 104,984
| 2
| 209,969
|
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
For some reason in many American cartoons anvils fall from time to time onto heroes' heads. Of course, safes, wardrobes, cruisers, planes fall sometimes too... But anvils do so most of all.
Anvils come in different sizes and shapes. Quite often they get the hero stuck deep in the ground. But have you ever thought who throws anvils from the sky? From what height? We are sure that such questions have never troubled you!
It turns out that throwing an anvil properly is not an easy task at all. Let's describe one of the most popular anvil throwing models.
Let the height p of the potential victim vary in the range [0;a] and the direction of the wind q vary in the range [ - b;b]. p and q could be any real (floating) numbers. Then we can assume that the anvil will fit the toon's head perfectly only if the following equation has at least one real root:
<image>
Determine the probability with which an aim can be successfully hit by an anvil.
You can assume that the p and q coefficients are chosen equiprobably and independently in their ranges.
Input
The first line contains integer t (1 ≤ t ≤ 10000) — amount of testcases.
Each of the following t lines contain two space-separated integers a and b (0 ≤ a, b ≤ 106).
Pretests contain all the tests with 0 < a < 10, 0 ≤ b < 10.
Output
Print t lines — the probability of a successful anvil hit for each testcase. The absolute or relative error of the answer should not exceed 10 - 6.
Examples
Input
2
4 2
1 2
Output
0.6250000000
0.5312500000
Submitted Solution:
```
t = int( input() )
for i in range( t ):
a, b = list( map( int, input().split() ) )
if a == 0:
print( 0.5 )
elif b == 0:
print( 1 )
else:
if a < 4*b:
ans = ( 0.5 + a/(16*b) )
else:
ans = 1 - b/a
print( ans )
```
|
instruction
| 0
| 104,985
| 2
| 209,970
|
No
|
output
| 1
| 104,985
| 2
| 209,971
|
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
For some reason in many American cartoons anvils fall from time to time onto heroes' heads. Of course, safes, wardrobes, cruisers, planes fall sometimes too... But anvils do so most of all.
Anvils come in different sizes and shapes. Quite often they get the hero stuck deep in the ground. But have you ever thought who throws anvils from the sky? From what height? We are sure that such questions have never troubled you!
It turns out that throwing an anvil properly is not an easy task at all. Let's describe one of the most popular anvil throwing models.
Let the height p of the potential victim vary in the range [0;a] and the direction of the wind q vary in the range [ - b;b]. p and q could be any real (floating) numbers. Then we can assume that the anvil will fit the toon's head perfectly only if the following equation has at least one real root:
<image>
Determine the probability with which an aim can be successfully hit by an anvil.
You can assume that the p and q coefficients are chosen equiprobably and independently in their ranges.
Input
The first line contains integer t (1 ≤ t ≤ 10000) — amount of testcases.
Each of the following t lines contain two space-separated integers a and b (0 ≤ a, b ≤ 106).
Pretests contain all the tests with 0 < a < 10, 0 ≤ b < 10.
Output
Print t lines — the probability of a successful anvil hit for each testcase. The absolute or relative error of the answer should not exceed 10 - 6.
Examples
Input
2
4 2
1 2
Output
0.6250000000
0.5312500000
Submitted Solution:
```
from fractions import Fraction
t = int(input())
for _ in range(t):
a, b = map(lambda x: Fraction(x), input().split(' '))
if b == 0:
print(1)
continue
elif a == 0:
print(0)
continue
up = a * (b + b + a / 4) / 2 - max(0, a - 4 * b) * (a / 4 - b) / 2
down = a * 2 * b
print(float(up/down))
```
|
instruction
| 0
| 104,986
| 2
| 209,972
|
No
|
output
| 1
| 104,986
| 2
| 209,973
|
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
Harry came to know from Dumbledore that Salazar Slytherin's locket is a horcrux. This locket was present earlier at 12 Grimmauld Place, the home of Sirius Black's mother. It was stolen from there and is now present in the Ministry of Magic in the office of Dolorous Umbridge, Harry's former Defense Against the Dark Arts teacher.
Harry, Ron and Hermione are infiltrating the Ministry. Upon reaching Umbridge's office, they observed a code lock with a puzzle asking them to calculate count of magic numbers between two integers l and r (both inclusive).
Harry remembered from his detention time with Umbridge that she defined a magic number as a number which when converted to a given base b, all the digits from 0 to b - 1 appear even number of times in its representation without any leading zeros.
You have to answer q queries to unlock the office. Each query has three integers bi, li and ri, the base and the range for which you have to find the count of magic numbers.
Input
First line of input contains q (1 ≤ q ≤ 105) — number of queries.
Each of the next q lines contain three space separated integers bi, li, ri (2 ≤ bi ≤ 10, 1 ≤ li ≤ ri ≤ 1018).
Output
You have to output q lines, each containing a single integer, the answer to the corresponding query.
Examples
Input
2
2 4 9
3 1 10
Output
1
2
Input
2
2 1 100
5 1 100
Output
21
4
Note
In sample test case 1, for first query, when we convert numbers 4 to 9 into base 2, we get:
* 4 = 1002,
* 5 = 1012,
* 6 = 1102,
* 7 = 1112,
* 8 = 10002,
* 9 = 10012.
Out of these, only base 2 representation of 9 has even number of 1 and 0. Thus, the answer is 1.
Submitted Solution:
```
n = int(input())
for i in range(n):
l = list(map(int, input().split()))
base = l[0]
count = 0
for j in range(l[1], l[2]+1):
print("-"+str(j))
flag = 0
new = ""
while j:
mod = j % base
j = j // base
new = chr(48 + mod + 7*(mod > 9)) + new
listzero = [0]*base
print(new+"----"+str(j))
#print(listzero)
for k in new:
listzero[int(k)] = listzero[int(k)] + 1
print(listzero)
for kin in listzero:
if kin%2==0:
continue
else:
flag = 1
break
if flag == 0:
count = count + 1
print(count)
```
|
instruction
| 0
| 105,003
| 2
| 210,006
|
No
|
output
| 1
| 105,003
| 2
| 210,007
|
Provide tags and a correct Python 3 solution for this coding contest problem.
Today you are going to lead a group of elven archers to defend the castle that is attacked by an army of angry orcs. Three sides of the castle are protected by impassable mountains and the remaining side is occupied by a long wall that is split into n sections. At this moment there are exactly ai archers located at the i-th section of this wall. You know that archer who stands at section i can shoot orcs that attack section located at distance not exceeding r, that is all such sections j that |i - j| ≤ r. In particular, r = 0 means that archers are only capable of shooting at orcs who attack section i.
Denote as defense level of section i the total number of archers who can shoot at the orcs attacking this section. Reliability of the defense plan is the minimum value of defense level of individual wall section.
There is a little time left till the attack so you can't redistribute archers that are already located at the wall. However, there is a reserve of k archers that you can distribute among wall sections in arbitrary way. You would like to achieve maximum possible reliability of the defence plan.
Input
The first line of the input contains three integers n, r and k (1 ≤ n ≤ 500 000, 0 ≤ r ≤ n, 0 ≤ k ≤ 1018) — the number of sections of the wall, the maximum distance to other section archers can still shoot and the number of archers yet to be distributed along the wall. The second line contains n integers a1, a2, ..., an (0 ≤ ai ≤ 109) — the current number of archers at each section.
Output
Print one integer — the maximum possible value of defense plan reliability, i.e. the maximum possible value of minimum defense level if we distribute k additional archers optimally.
Examples
Input
5 0 6
5 4 3 4 9
Output
5
Input
4 2 0
1 2 3 4
Output
6
Input
5 1 1
2 1 2 1 2
Output
3
|
instruction
| 0
| 105,019
| 2
| 210,038
|
Tags: binary search, data structures, greedy, two pointers
Correct Solution:
```
import sys
BORDER = 1 << 30
def build(x=0):
high = low = 0
i = 0
while x and i < 30:
if x & 1:
low += (1 << i)
x >>= 1
i += 1
i = 0
while x:
if x & 1:
high += (1 << i)
x >>= 1
i += 1
return high, low
def add(x_high, x_low, y_high, y_low):
x_high += y_high
x_low += y_low
if x_low >= BORDER:
x_low -= BORDER
x_high += 1
elif x_low < 0:
x_low += BORDER
x_high -= 1
return x_high, x_low
n, r, k = map(int, sys.stdin.buffer.readline().decode('utf-8').split())
a = list(map(int, sys.stdin.buffer.readline().decode('utf-8').split()))
k_high, k_low = build(k)
left = build(sum(a[:r]))
minus_high, minus_low = [0]*n, [0]*n
w = 2*r+1
def solve(level_high, level_low):
used_high = used_low = 0
acc_high, acc_low = left
for i in range(n):
if minus_low[i] or minus_high[i]:
acc_high, acc_low =\
add(acc_high, acc_low, -minus_high[i], -minus_low[i])
minus_high[i] = minus_low[i] = 0
acc_high, acc_low = \
add(acc_high, acc_low,
0, (a[i+r] if i+r < n else 0) - (a[i-r-1] if i-r >= 1 else 0))
if acc_high < level_high or acc_high == level_high and acc_low < level_low:
used_high, used_low = add(
used_high, used_low,
level_high - acc_high, level_low - acc_low)
if used_high > k_high or used_high == k_high and used_low > k_low:
break
if i+w < n:
minus_high[i+w] = level_high - acc_high
minus_low[i+w] = level_low - acc_low
acc_high = level_high
acc_low = level_low
for i in range(i+1, n):
if minus_low[i] or minus_high[i]:
minus_low[i] = minus_high[i] = 0
return used_high < k_high or used_high == k_high and used_low <= k_low
ok, ng = min(a) + k // n, k + sum(a) + 1
while abs(ok - ng) > 1:
mid = (ok + ng) >> 1
if solve(*build(mid)):
ok = mid
else:
ng = mid
print(ok)
```
|
output
| 1
| 105,019
| 2
| 210,039
|
Provide tags and a correct Python 3 solution for this coding contest problem.
Today you are going to lead a group of elven archers to defend the castle that is attacked by an army of angry orcs. Three sides of the castle are protected by impassable mountains and the remaining side is occupied by a long wall that is split into n sections. At this moment there are exactly ai archers located at the i-th section of this wall. You know that archer who stands at section i can shoot orcs that attack section located at distance not exceeding r, that is all such sections j that |i - j| ≤ r. In particular, r = 0 means that archers are only capable of shooting at orcs who attack section i.
Denote as defense level of section i the total number of archers who can shoot at the orcs attacking this section. Reliability of the defense plan is the minimum value of defense level of individual wall section.
There is a little time left till the attack so you can't redistribute archers that are already located at the wall. However, there is a reserve of k archers that you can distribute among wall sections in arbitrary way. You would like to achieve maximum possible reliability of the defence plan.
Input
The first line of the input contains three integers n, r and k (1 ≤ n ≤ 500 000, 0 ≤ r ≤ n, 0 ≤ k ≤ 1018) — the number of sections of the wall, the maximum distance to other section archers can still shoot and the number of archers yet to be distributed along the wall. The second line contains n integers a1, a2, ..., an (0 ≤ ai ≤ 109) — the current number of archers at each section.
Output
Print one integer — the maximum possible value of defense plan reliability, i.e. the maximum possible value of minimum defense level if we distribute k additional archers optimally.
Examples
Input
5 0 6
5 4 3 4 9
Output
5
Input
4 2 0
1 2 3 4
Output
6
Input
5 1 1
2 1 2 1 2
Output
3
|
instruction
| 0
| 105,020
| 2
| 210,040
|
Tags: binary search, data structures, greedy, two pointers
Correct Solution:
```
import sys
border = 1 << 30
def build(x=0):
res = [0, 0]
i = 0
while x and i < 30:
if x & 1:
res[1] += (1 << i)
x >>= 1
i += 1
i = 0
while x:
if x & 1:
res[0] += (1 << i)
x >>= 1
i += 1
return res
n, r, k = map(int, sys.stdin.buffer.readline().decode('utf-8').split())
a = list(map(int, sys.stdin.buffer.readline().decode('utf-8').split()))
k_big, k_small = build(k)
left = build(sum(a[:r]))
minus_big, minus_small = [0]*n, [0]*n
w = 2*r+1
def solve(level_big, level_small):
used_big = used_small = 0
acc_big, acc_small = left
for i in range(n):
if minus_small[i] or minus_big[i]:
acc_big -= minus_big[i]
acc_small -= minus_small[i]
if acc_small < 0:
acc_small += border
acc_big -= 1
elif acc_small >= border:
acc_small -= border
acc_big += 1
minus_big[i] = minus_small[i] = 0
acc_small += (a[i+r] if i+r < n else 0) - (a[i-r-1] if i-r >= 1 else 0)
if acc_small >= border:
acc_small -= border
acc_big += 1
elif acc_small < 0:
acc_small += border
acc_big -= 1
if acc_big < level_big or acc_big == level_big and acc_small < level_small:
used_big += level_big - acc_big
used_small += level_small - acc_small
if used_small >= border:
used_small -= border
used_big += 1
elif used_small < 0:
used_small += border
used_big -= 1
if used_big > k_big or used_big == k_big and used_small > k_small:
break
if i+w < n:
minus_big[i+w] = level_big - acc_big
minus_small[i+w] = level_small - acc_small
acc_big = level_big
acc_small = level_small
for i in range(i+1, n):
if minus_small[i] or minus_big[i]:
minus_small[i] = minus_big[i] = 0
return used_big < k_big or used_big == k_big and used_small <= k_small
ok, ng = min(a), k + sum(a) + 1
while abs(ok - ng) > 1:
mid = (ok + ng) >> 1
if solve(*build(mid)):
ok = mid
else:
ng = mid
print(ok)
```
|
output
| 1
| 105,020
| 2
| 210,041
|
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
Today you are going to lead a group of elven archers to defend the castle that is attacked by an army of angry orcs. Three sides of the castle are protected by impassable mountains and the remaining side is occupied by a long wall that is split into n sections. At this moment there are exactly ai archers located at the i-th section of this wall. You know that archer who stands at section i can shoot orcs that attack section located at distance not exceeding r, that is all such sections j that |i - j| ≤ r. In particular, r = 0 means that archers are only capable of shooting at orcs who attack section i.
Denote as defense level of section i the total number of archers who can shoot at the orcs attacking this section. Reliability of the defense plan is the minimum value of defense level of individual wall section.
There is a little time left till the attack so you can't redistribute archers that are already located at the wall. However, there is a reserve of k archers that you can distribute among wall sections in arbitrary way. You would like to achieve maximum possible reliability of the defence plan.
Input
The first line of the input contains three integers n, r and k (1 ≤ n ≤ 500 000, 0 ≤ r ≤ n, 0 ≤ k ≤ 1018) — the number of sections of the wall, the maximum distance to other section archers can still shoot and the number of archers yet to be distributed along the wall. The second line contains n integers a1, a2, ..., an (0 ≤ ai ≤ 109) — the current number of archers at each section.
Output
Print one integer — the maximum possible value of defense plan reliability, i.e. the maximum possible value of minimum defense level if we distribute k additional archers optimally.
Examples
Input
5 0 6
5 4 3 4 9
Output
5
Input
4 2 0
1 2 3 4
Output
6
Input
5 1 1
2 1 2 1 2
Output
3
Submitted Solution:
```
from copy import copy
n, r, k = [100, 0, 1000]
a = [int(el) for el in input().split(" ")]
if n == 1:
print(a[0]+k)
else:
def get_weight(i, radius, ar):
rez = -ar[i]
for d in range(radius+1):
if i-d >= 0:
rez += ar[i-d]
if i+d < len(ar):
rez += ar[i+d]
return rez
def get_mod_array(i, ar):
rez = copy(ar)
rez[i] += 1
return rez
def get_weight_array(ar, radius):
return [get_weight(j, radius, ar) for j in range(len(ar))]
def get_next_step(ar, radius):
rez = None
min_val = min(*get_weight_array(ar, radius))
min_count = None
min_position = ar.index(min(*ar))
left_limit = min_position - radius
if left_limit < 0:
left_limit = 0
right_limit = min_position + radius + 1
if right_limit > len(ar):
right_limit = len(ar)
for i in range(left_limit, right_limit):
temp = get_mod_array(i, ar)
temp_w = get_weight_array(temp, radius)
temp_min_count = temp_w.count(min_val)
if (min_count is None) or (temp_min_count < min_count):
rez = temp
if min_count is None:
min_count = temp_min_count
else:
break
return rez
for i in range(k):
a = get_next_step(a, r)
print(min(*get_weight_array(a, r)))
```
|
instruction
| 0
| 105,021
| 2
| 210,042
|
No
|
output
| 1
| 105,021
| 2
| 210,043
|
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
Today you are going to lead a group of elven archers to defend the castle that is attacked by an army of angry orcs. Three sides of the castle are protected by impassable mountains and the remaining side is occupied by a long wall that is split into n sections. At this moment there are exactly ai archers located at the i-th section of this wall. You know that archer who stands at section i can shoot orcs that attack section located at distance not exceeding r, that is all such sections j that |i - j| ≤ r. In particular, r = 0 means that archers are only capable of shooting at orcs who attack section i.
Denote as defense level of section i the total number of archers who can shoot at the orcs attacking this section. Reliability of the defense plan is the minimum value of defense level of individual wall section.
There is a little time left till the attack so you can't redistribute archers that are already located at the wall. However, there is a reserve of k archers that you can distribute among wall sections in arbitrary way. You would like to achieve maximum possible reliability of the defence plan.
Input
The first line of the input contains three integers n, r and k (1 ≤ n ≤ 500 000, 0 ≤ r ≤ n, 0 ≤ k ≤ 1018) — the number of sections of the wall, the maximum distance to other section archers can still shoot and the number of archers yet to be distributed along the wall. The second line contains n integers a1, a2, ..., an (0 ≤ ai ≤ 109) — the current number of archers at each section.
Output
Print one integer — the maximum possible value of defense plan reliability, i.e. the maximum possible value of minimum defense level if we distribute k additional archers optimally.
Examples
Input
5 0 6
5 4 3 4 9
Output
5
Input
4 2 0
1 2 3 4
Output
6
Input
5 1 1
2 1 2 1 2
Output
3
Submitted Solution:
```
def check(res, x):
sc = [0] * n
cur = 0
for i in range(n):
cur -= sc[i]
if sec[i] + cur < x:
delta = x - sec[i] - cur
if res < delta:
return False
res -= delta
cur += delta
if i + 2 * rd + 1 < n:
sc[i + 2 * rd + 1] = delta
return True
n, rd, k = map(int, input().split())
a = [int(x) for x in input().split()]
sec = [0] * n
for i in range(n):
for j in range(max(0, i - rd), min(n, i + rd + 1)):
sec[j] += a[i]
l = max(min(sec) - 1, 0)
r = k + l + 1
while r - l > 1:
mid = (r + l) // 2
if check(k, mid):
l = mid
else:
r = mid
print(l)
```
|
instruction
| 0
| 105,022
| 2
| 210,044
|
No
|
output
| 1
| 105,022
| 2
| 210,045
|
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
Today you are going to lead a group of elven archers to defend the castle that is attacked by an army of angry orcs. Three sides of the castle are protected by impassable mountains and the remaining side is occupied by a long wall that is split into n sections. At this moment there are exactly ai archers located at the i-th section of this wall. You know that archer who stands at section i can shoot orcs that attack section located at distance not exceeding r, that is all such sections j that |i - j| ≤ r. In particular, r = 0 means that archers are only capable of shooting at orcs who attack section i.
Denote as defense level of section i the total number of archers who can shoot at the orcs attacking this section. Reliability of the defense plan is the minimum value of defense level of individual wall section.
There is a little time left till the attack so you can't redistribute archers that are already located at the wall. However, there is a reserve of k archers that you can distribute among wall sections in arbitrary way. You would like to achieve maximum possible reliability of the defence plan.
Input
The first line of the input contains three integers n, r and k (1 ≤ n ≤ 500 000, 0 ≤ r ≤ n, 0 ≤ k ≤ 1018) — the number of sections of the wall, the maximum distance to other section archers can still shoot and the number of archers yet to be distributed along the wall. The second line contains n integers a1, a2, ..., an (0 ≤ ai ≤ 109) — the current number of archers at each section.
Output
Print one integer — the maximum possible value of defense plan reliability, i.e. the maximum possible value of minimum defense level if we distribute k additional archers optimally.
Examples
Input
5 0 6
5 4 3 4 9
Output
5
Input
4 2 0
1 2 3 4
Output
6
Input
5 1 1
2 1 2 1 2
Output
3
Submitted Solution:
```
import sys
from itertools import accumulate
from collections import Counter
n, r, k = map(int, input().split())
a = list(accumulate([0]+list(map(int, input().split()))))
def solve(level):
minus = Counter()
plus = 0
used = 0
for i in range(1, n+1):
plus += minus[i]
x = a[min(n, i+r)] - a[max(0, i-r-1)] + plus
if x < level:
used += level - x
plus += level - x
minus[i+r+1] -= level - x
return used <= k
ok, ng = min(a), 2*10**18
while abs(ok - ng) > 1:
mid = (ok + ng) >> 1
if solve(mid):
ok = mid
else:
ng = mid
print(ok)
```
|
instruction
| 0
| 105,023
| 2
| 210,046
|
No
|
output
| 1
| 105,023
| 2
| 210,047
|
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
Today you are going to lead a group of elven archers to defend the castle that is attacked by an army of angry orcs. Three sides of the castle are protected by impassable mountains and the remaining side is occupied by a long wall that is split into n sections. At this moment there are exactly ai archers located at the i-th section of this wall. You know that archer who stands at section i can shoot orcs that attack section located at distance not exceeding r, that is all such sections j that |i - j| ≤ r. In particular, r = 0 means that archers are only capable of shooting at orcs who attack section i.
Denote as defense level of section i the total number of archers who can shoot at the orcs attacking this section. Reliability of the defense plan is the minimum value of defense level of individual wall section.
There is a little time left till the attack so you can't redistribute archers that are already located at the wall. However, there is a reserve of k archers that you can distribute among wall sections in arbitrary way. You would like to achieve maximum possible reliability of the defence plan.
Input
The first line of the input contains three integers n, r and k (1 ≤ n ≤ 500 000, 0 ≤ r ≤ n, 0 ≤ k ≤ 1018) — the number of sections of the wall, the maximum distance to other section archers can still shoot and the number of archers yet to be distributed along the wall. The second line contains n integers a1, a2, ..., an (0 ≤ ai ≤ 109) — the current number of archers at each section.
Output
Print one integer — the maximum possible value of defense plan reliability, i.e. the maximum possible value of minimum defense level if we distribute k additional archers optimally.
Examples
Input
5 0 6
5 4 3 4 9
Output
5
Input
4 2 0
1 2 3 4
Output
6
Input
5 1 1
2 1 2 1 2
Output
3
Submitted Solution:
```
def check(res, x):
sc = [0] * n
cur = 0
for i in range(n):
cur -= sc[i]
if sec[i] + cur < x:
delta = x - sec[i] - cur
if res < delta:
return False
res -= delta
cur += delta
if i + 2 * rd + 1 < n:
sc[i + 2 * rd + 1] = delta
return True
n, rd, k = map(int, input().split())
a = [int(x) for x in input().split()]
sec = [0] * n
for i in range(n):
for j in range(max(0, i - rd), min(n, i + rd + 1)):
sec[j] += a[i]
l = max(min(sec) - 1, 0)
r = k + l
while r - l > 1:
mid = (r + l) // 2
if check(k, mid):
l = mid
else:
r = mid
print(l)
```
|
instruction
| 0
| 105,024
| 2
| 210,048
|
No
|
output
| 1
| 105,024
| 2
| 210,049
|
Provide tags and a correct Python 3 solution for this coding contest problem.
Vasya the Great Magician and Conjurer loves all kinds of miracles and wizardry. In one wave of a magic wand he can turn an object into something else. But, as you all know, there is no better magic in the Universe than the magic of numbers. That's why Vasya adores math and spends a lot of time turning some numbers into some other ones.
This morning he has n cards with integers lined up in front of him. Each integer is not less than 1, but not greater than l. When Vasya waves his magic wand, two rightmost cards vanish from the line and a new card magically appears in their place. It contains the difference between the left and the right numbers on the two vanished cards. Vasya was very interested to know what would happen next, and so he waved with his magic wand on and on, until the table had a single card left.
Suppose that Vasya originally had the following cards: 4, 1, 1, 3 (listed from left to right). Then after the first wave the line would be: 4, 1, -2, and after the second one: 4, 3, and after the third one the table would have a single card with number 1.
Please note that in spite of the fact that initially all the numbers on the cards were not less than 1 and not greater than l, the numbers on the appearing cards can be anything, no restrictions are imposed on them.
It is now evening. Vasya is very tired and wants to return everything back, but does not remember which cards he had in the morning. He only remembers that there were n cards, they contained integers from 1 to l, and after all magical actions he was left with a single card containing number d.
Help Vasya to recover the initial set of cards with numbers.
Input
The single line contains three space-separated integers: n (2 ≤ n ≤ 100) — the initial number of cards on the table, d (|d| ≤ 104) — the number on the card that was left on the table after all the magical actions, and l (1 ≤ l ≤ 100) — the limits for the initial integers.
Output
If Vasya is mistaken, that is, if there doesn't exist a set that meets the requirements given in the statement, then print a single number -1, otherwise print the sought set containing n integers from 1 to l. Separate the integers by spaces. Print the integers in the order, in which they were written on the cards from left to right. If there are several suitable sets of numbers, you can print any of them.
Examples
Input
3 3 2
Output
2 1 2
Input
5 -4 3
Output
-1
Input
5 -4 4
Output
2 4 1 4 1
|
instruction
| 0
| 106,428
| 2
| 212,856
|
Tags: constructive algorithms, greedy
Correct Solution:
```
n, d, l = map(int, input().split())
x, y = (n + 1) // 2 - l * (n // 2), l * ((n + 1) // 2) - n // 2
if x > d or y < d: print(-1)
elif l == 1: print('1 ' * n)
else:
a, b = str(l) + ' ', '1 '
u, v = (d - x) // (l - 1), (d - x) % (l - 1)
p = (a + b) * (u // 2)
if u % 2:
p += a
if v > 0: p += str(l - v) + ' '
elif v > 0: p += str(1 + v) + ' '
k = u + int(v > 0)
if k < n: p += a * (k % 2) + (b + a) * ((n - k - k % 2) // 2) + b * ((n - k - k % 2) % 2)
print(p)
```
|
output
| 1
| 106,428
| 2
| 212,857
|
Provide tags and a correct Python 3 solution for this coding contest problem.
Vasya the Great Magician and Conjurer loves all kinds of miracles and wizardry. In one wave of a magic wand he can turn an object into something else. But, as you all know, there is no better magic in the Universe than the magic of numbers. That's why Vasya adores math and spends a lot of time turning some numbers into some other ones.
This morning he has n cards with integers lined up in front of him. Each integer is not less than 1, but not greater than l. When Vasya waves his magic wand, two rightmost cards vanish from the line and a new card magically appears in their place. It contains the difference between the left and the right numbers on the two vanished cards. Vasya was very interested to know what would happen next, and so he waved with his magic wand on and on, until the table had a single card left.
Suppose that Vasya originally had the following cards: 4, 1, 1, 3 (listed from left to right). Then after the first wave the line would be: 4, 1, -2, and after the second one: 4, 3, and after the third one the table would have a single card with number 1.
Please note that in spite of the fact that initially all the numbers on the cards were not less than 1 and not greater than l, the numbers on the appearing cards can be anything, no restrictions are imposed on them.
It is now evening. Vasya is very tired and wants to return everything back, but does not remember which cards he had in the morning. He only remembers that there were n cards, they contained integers from 1 to l, and after all magical actions he was left with a single card containing number d.
Help Vasya to recover the initial set of cards with numbers.
Input
The single line contains three space-separated integers: n (2 ≤ n ≤ 100) — the initial number of cards on the table, d (|d| ≤ 104) — the number on the card that was left on the table after all the magical actions, and l (1 ≤ l ≤ 100) — the limits for the initial integers.
Output
If Vasya is mistaken, that is, if there doesn't exist a set that meets the requirements given in the statement, then print a single number -1, otherwise print the sought set containing n integers from 1 to l. Separate the integers by spaces. Print the integers in the order, in which they were written on the cards from left to right. If there are several suitable sets of numbers, you can print any of them.
Examples
Input
3 3 2
Output
2 1 2
Input
5 -4 3
Output
-1
Input
5 -4 4
Output
2 4 1 4 1
|
instruction
| 0
| 106,429
| 2
| 212,858
|
Tags: constructive algorithms, greedy
Correct Solution:
```
n,d,l=list(map(int,input().split()))
a=[0]*n
for i in range(n):
if i==n-1:
a[i]=d
else:
if d>=l:
a[i]=l
d=l-d
elif d<1:
a[i]=1
d=-d+1
else:
a[i]=d+1
d=1
if a[-1]>l or a[-1]<1:
print(-1)
else:
for i in range(n):
print(a[i],end=' ')
```
|
output
| 1
| 106,429
| 2
| 212,859
|
Provide tags and a correct Python 3 solution for this coding contest problem.
Vasya the Great Magician and Conjurer loves all kinds of miracles and wizardry. In one wave of a magic wand he can turn an object into something else. But, as you all know, there is no better magic in the Universe than the magic of numbers. That's why Vasya adores math and spends a lot of time turning some numbers into some other ones.
This morning he has n cards with integers lined up in front of him. Each integer is not less than 1, but not greater than l. When Vasya waves his magic wand, two rightmost cards vanish from the line and a new card magically appears in their place. It contains the difference between the left and the right numbers on the two vanished cards. Vasya was very interested to know what would happen next, and so he waved with his magic wand on and on, until the table had a single card left.
Suppose that Vasya originally had the following cards: 4, 1, 1, 3 (listed from left to right). Then after the first wave the line would be: 4, 1, -2, and after the second one: 4, 3, and after the third one the table would have a single card with number 1.
Please note that in spite of the fact that initially all the numbers on the cards were not less than 1 and not greater than l, the numbers on the appearing cards can be anything, no restrictions are imposed on them.
It is now evening. Vasya is very tired and wants to return everything back, but does not remember which cards he had in the morning. He only remembers that there were n cards, they contained integers from 1 to l, and after all magical actions he was left with a single card containing number d.
Help Vasya to recover the initial set of cards with numbers.
Input
The single line contains three space-separated integers: n (2 ≤ n ≤ 100) — the initial number of cards on the table, d (|d| ≤ 104) — the number on the card that was left on the table after all the magical actions, and l (1 ≤ l ≤ 100) — the limits for the initial integers.
Output
If Vasya is mistaken, that is, if there doesn't exist a set that meets the requirements given in the statement, then print a single number -1, otherwise print the sought set containing n integers from 1 to l. Separate the integers by spaces. Print the integers in the order, in which they were written on the cards from left to right. If there are several suitable sets of numbers, you can print any of them.
Examples
Input
3 3 2
Output
2 1 2
Input
5 -4 3
Output
-1
Input
5 -4 4
Output
2 4 1 4 1
|
instruction
| 0
| 106,430
| 2
| 212,860
|
Tags: constructive algorithms, greedy
Correct Solution:
```
nn=input()
a=[int(i) for i in nn.split()]
d=a[1]
l=a[2]
n=a[0]
oddn=int(n/2)+n%2
evenn=int(n/2)
a=[]
if d>(oddn*l-evenn) or d<(oddn-evenn*l):
print(-1)
else:
if n%2:
d-=1
for i in range(n):
a.append(int(1))
for i in range(n):
if i%2==0:
if d>0:
if d<l:
a[i]+=d
d-=d
else:
a[i]+=(l-1)
d-=(l-1)
else:
if d<0:
if d>(-l):
a[i]+=(-d)
d+=-d
else :
a[i]+=(l-1)
d+=(l-1)
for i in range(n):
print(a[i],end=" ")
```
|
output
| 1
| 106,430
| 2
| 212,861
|
Provide tags and a correct Python 3 solution for this coding contest problem.
Vasya the Great Magician and Conjurer loves all kinds of miracles and wizardry. In one wave of a magic wand he can turn an object into something else. But, as you all know, there is no better magic in the Universe than the magic of numbers. That's why Vasya adores math and spends a lot of time turning some numbers into some other ones.
This morning he has n cards with integers lined up in front of him. Each integer is not less than 1, but not greater than l. When Vasya waves his magic wand, two rightmost cards vanish from the line and a new card magically appears in their place. It contains the difference between the left and the right numbers on the two vanished cards. Vasya was very interested to know what would happen next, and so he waved with his magic wand on and on, until the table had a single card left.
Suppose that Vasya originally had the following cards: 4, 1, 1, 3 (listed from left to right). Then after the first wave the line would be: 4, 1, -2, and after the second one: 4, 3, and after the third one the table would have a single card with number 1.
Please note that in spite of the fact that initially all the numbers on the cards were not less than 1 and not greater than l, the numbers on the appearing cards can be anything, no restrictions are imposed on them.
It is now evening. Vasya is very tired and wants to return everything back, but does not remember which cards he had in the morning. He only remembers that there were n cards, they contained integers from 1 to l, and after all magical actions he was left with a single card containing number d.
Help Vasya to recover the initial set of cards with numbers.
Input
The single line contains three space-separated integers: n (2 ≤ n ≤ 100) — the initial number of cards on the table, d (|d| ≤ 104) — the number on the card that was left on the table after all the magical actions, and l (1 ≤ l ≤ 100) — the limits for the initial integers.
Output
If Vasya is mistaken, that is, if there doesn't exist a set that meets the requirements given in the statement, then print a single number -1, otherwise print the sought set containing n integers from 1 to l. Separate the integers by spaces. Print the integers in the order, in which they were written on the cards from left to right. If there are several suitable sets of numbers, you can print any of them.
Examples
Input
3 3 2
Output
2 1 2
Input
5 -4 3
Output
-1
Input
5 -4 4
Output
2 4 1 4 1
|
instruction
| 0
| 106,431
| 2
| 212,862
|
Tags: constructive algorithms, greedy
Correct Solution:
```
n,d,l=map(int,input().split())
ans=[]
for i in range(n-1):
if d<1:
ans.append(1)
d=1-d
else:
ans.append(l)
d=l-d
if 1<=d<=l:
print(*(ans+[d]))
else:
print(-1)
```
|
output
| 1
| 106,431
| 2
| 212,863
|
Provide tags and a correct Python 3 solution for this coding contest problem.
Vasya the Great Magician and Conjurer loves all kinds of miracles and wizardry. In one wave of a magic wand he can turn an object into something else. But, as you all know, there is no better magic in the Universe than the magic of numbers. That's why Vasya adores math and spends a lot of time turning some numbers into some other ones.
This morning he has n cards with integers lined up in front of him. Each integer is not less than 1, but not greater than l. When Vasya waves his magic wand, two rightmost cards vanish from the line and a new card magically appears in their place. It contains the difference between the left and the right numbers on the two vanished cards. Vasya was very interested to know what would happen next, and so he waved with his magic wand on and on, until the table had a single card left.
Suppose that Vasya originally had the following cards: 4, 1, 1, 3 (listed from left to right). Then after the first wave the line would be: 4, 1, -2, and after the second one: 4, 3, and after the third one the table would have a single card with number 1.
Please note that in spite of the fact that initially all the numbers on the cards were not less than 1 and not greater than l, the numbers on the appearing cards can be anything, no restrictions are imposed on them.
It is now evening. Vasya is very tired and wants to return everything back, but does not remember which cards he had in the morning. He only remembers that there were n cards, they contained integers from 1 to l, and after all magical actions he was left with a single card containing number d.
Help Vasya to recover the initial set of cards with numbers.
Input
The single line contains three space-separated integers: n (2 ≤ n ≤ 100) — the initial number of cards on the table, d (|d| ≤ 104) — the number on the card that was left on the table after all the magical actions, and l (1 ≤ l ≤ 100) — the limits for the initial integers.
Output
If Vasya is mistaken, that is, if there doesn't exist a set that meets the requirements given in the statement, then print a single number -1, otherwise print the sought set containing n integers from 1 to l. Separate the integers by spaces. Print the integers in the order, in which they were written on the cards from left to right. If there are several suitable sets of numbers, you can print any of them.
Examples
Input
3 3 2
Output
2 1 2
Input
5 -4 3
Output
-1
Input
5 -4 4
Output
2 4 1 4 1
|
instruction
| 0
| 106,432
| 2
| 212,864
|
Tags: constructive algorithms, greedy
Correct Solution:
```
n,d,l=map(int,input().split())
if d < (n-n//2) -(n//2)*l or d > (n-n//2)*l -(n//2):
print(-1)
else:
arr=[1]*n
sum1=l*(n-n//2)
sum2=n//2
for i in range(0,n,2):
arr[i]=l
i=0
j=1
while 1 :
if i<n:
if arr[i]==1:
i+=2
if j<n:
if arr[j]==l:
j+=2
if sum1-sum2==d:
break
elif i<n:
if sum1-sum2>d:
sum1-=1
arr[i]-=1
elif j<n:
if sum1-sum2>d:
sum2+=1
arr[j]+=1
print(*arr)
```
|
output
| 1
| 106,432
| 2
| 212,865
|
Provide tags and a correct Python 3 solution for this coding contest problem.
Vasya the Great Magician and Conjurer loves all kinds of miracles and wizardry. In one wave of a magic wand he can turn an object into something else. But, as you all know, there is no better magic in the Universe than the magic of numbers. That's why Vasya adores math and spends a lot of time turning some numbers into some other ones.
This morning he has n cards with integers lined up in front of him. Each integer is not less than 1, but not greater than l. When Vasya waves his magic wand, two rightmost cards vanish from the line and a new card magically appears in their place. It contains the difference between the left and the right numbers on the two vanished cards. Vasya was very interested to know what would happen next, and so he waved with his magic wand on and on, until the table had a single card left.
Suppose that Vasya originally had the following cards: 4, 1, 1, 3 (listed from left to right). Then after the first wave the line would be: 4, 1, -2, and after the second one: 4, 3, and after the third one the table would have a single card with number 1.
Please note that in spite of the fact that initially all the numbers on the cards were not less than 1 and not greater than l, the numbers on the appearing cards can be anything, no restrictions are imposed on them.
It is now evening. Vasya is very tired and wants to return everything back, but does not remember which cards he had in the morning. He only remembers that there were n cards, they contained integers from 1 to l, and after all magical actions he was left with a single card containing number d.
Help Vasya to recover the initial set of cards with numbers.
Input
The single line contains three space-separated integers: n (2 ≤ n ≤ 100) — the initial number of cards on the table, d (|d| ≤ 104) — the number on the card that was left on the table after all the magical actions, and l (1 ≤ l ≤ 100) — the limits for the initial integers.
Output
If Vasya is mistaken, that is, if there doesn't exist a set that meets the requirements given in the statement, then print a single number -1, otherwise print the sought set containing n integers from 1 to l. Separate the integers by spaces. Print the integers in the order, in which they were written on the cards from left to right. If there are several suitable sets of numbers, you can print any of them.
Examples
Input
3 3 2
Output
2 1 2
Input
5 -4 3
Output
-1
Input
5 -4 4
Output
2 4 1 4 1
|
instruction
| 0
| 106,433
| 2
| 212,866
|
Tags: constructive algorithms, greedy
Correct Solution:
```
n, d, l = map(int, input().split())
m1 = (n // 2) * (1 - l)
m2 = (n // 2) * (l - 1)
if n % 2 != 0:
m1 += 1
m2 += l
if not (m1 <= d <= m2):
print(-1)
exit()
x = d - m1
res = [1 if i % 2 == 0 else l for i in range(n)]
i = 0
while x > 0:
if i % 2 == 0:
res[i] += min(l-1, x)
else:
res[i] -= min(l-1, x)
if i + 2 < n:
i += 2
else:
i = 1
x -= min(l-1, x)
print(*res)
```
|
output
| 1
| 106,433
| 2
| 212,867
|
Provide tags and a correct Python 3 solution for this coding contest problem.
Vasya the Great Magician and Conjurer loves all kinds of miracles and wizardry. In one wave of a magic wand he can turn an object into something else. But, as you all know, there is no better magic in the Universe than the magic of numbers. That's why Vasya adores math and spends a lot of time turning some numbers into some other ones.
This morning he has n cards with integers lined up in front of him. Each integer is not less than 1, but not greater than l. When Vasya waves his magic wand, two rightmost cards vanish from the line and a new card magically appears in their place. It contains the difference between the left and the right numbers on the two vanished cards. Vasya was very interested to know what would happen next, and so he waved with his magic wand on and on, until the table had a single card left.
Suppose that Vasya originally had the following cards: 4, 1, 1, 3 (listed from left to right). Then after the first wave the line would be: 4, 1, -2, and after the second one: 4, 3, and after the third one the table would have a single card with number 1.
Please note that in spite of the fact that initially all the numbers on the cards were not less than 1 and not greater than l, the numbers on the appearing cards can be anything, no restrictions are imposed on them.
It is now evening. Vasya is very tired and wants to return everything back, but does not remember which cards he had in the morning. He only remembers that there were n cards, they contained integers from 1 to l, and after all magical actions he was left with a single card containing number d.
Help Vasya to recover the initial set of cards with numbers.
Input
The single line contains three space-separated integers: n (2 ≤ n ≤ 100) — the initial number of cards on the table, d (|d| ≤ 104) — the number on the card that was left on the table after all the magical actions, and l (1 ≤ l ≤ 100) — the limits for the initial integers.
Output
If Vasya is mistaken, that is, if there doesn't exist a set that meets the requirements given in the statement, then print a single number -1, otherwise print the sought set containing n integers from 1 to l. Separate the integers by spaces. Print the integers in the order, in which they were written on the cards from left to right. If there are several suitable sets of numbers, you can print any of them.
Examples
Input
3 3 2
Output
2 1 2
Input
5 -4 3
Output
-1
Input
5 -4 4
Output
2 4 1 4 1
|
instruction
| 0
| 106,434
| 2
| 212,868
|
Tags: constructive algorithms, greedy
Correct Solution:
```
r=[]
n,d,l=map(int,input().split())
for i in range(1,n):
k=1 if d<=0 else l
r.append(k)
d=k-d
if 1<=d<=l:print(*r+[d])
else:print(-1)
```
|
output
| 1
| 106,434
| 2
| 212,869
|
Provide tags and a correct Python 3 solution for this coding contest problem.
Vasya the Great Magician and Conjurer loves all kinds of miracles and wizardry. In one wave of a magic wand he can turn an object into something else. But, as you all know, there is no better magic in the Universe than the magic of numbers. That's why Vasya adores math and spends a lot of time turning some numbers into some other ones.
This morning he has n cards with integers lined up in front of him. Each integer is not less than 1, but not greater than l. When Vasya waves his magic wand, two rightmost cards vanish from the line and a new card magically appears in their place. It contains the difference between the left and the right numbers on the two vanished cards. Vasya was very interested to know what would happen next, and so he waved with his magic wand on and on, until the table had a single card left.
Suppose that Vasya originally had the following cards: 4, 1, 1, 3 (listed from left to right). Then after the first wave the line would be: 4, 1, -2, and after the second one: 4, 3, and after the third one the table would have a single card with number 1.
Please note that in spite of the fact that initially all the numbers on the cards were not less than 1 and not greater than l, the numbers on the appearing cards can be anything, no restrictions are imposed on them.
It is now evening. Vasya is very tired and wants to return everything back, but does not remember which cards he had in the morning. He only remembers that there were n cards, they contained integers from 1 to l, and after all magical actions he was left with a single card containing number d.
Help Vasya to recover the initial set of cards with numbers.
Input
The single line contains three space-separated integers: n (2 ≤ n ≤ 100) — the initial number of cards on the table, d (|d| ≤ 104) — the number on the card that was left on the table after all the magical actions, and l (1 ≤ l ≤ 100) — the limits for the initial integers.
Output
If Vasya is mistaken, that is, if there doesn't exist a set that meets the requirements given in the statement, then print a single number -1, otherwise print the sought set containing n integers from 1 to l. Separate the integers by spaces. Print the integers in the order, in which they were written on the cards from left to right. If there are several suitable sets of numbers, you can print any of them.
Examples
Input
3 3 2
Output
2 1 2
Input
5 -4 3
Output
-1
Input
5 -4 4
Output
2 4 1 4 1
|
instruction
| 0
| 106,435
| 2
| 212,870
|
Tags: constructive algorithms, greedy
Correct Solution:
```
from sys import stdin,stdout
nmbr=lambda:int(stdin.readline())
lst = lambda: list(map(int, input().split()))
for _ in range(1):#nmbr():
n,d,mx=lst()
ans=[1]*n
sm=0
for i in range(n):
if i&1:sm-=ans[i]
else:sm+=ans[i]
p=0
while p<n and sm!=d:
if p&1 and sm>d and ans[p]<mx:
ans[p]+=1
sm-=1
elif p&1==0 and sm<d and ans[p]<mx:
ans[p]+=1
sm+=1
else:p+=1
# print(ans)
if sm==d:print(*ans)
else:print(-1)
```
|
output
| 1
| 106,435
| 2
| 212,871
|
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
Vasya the Great Magician and Conjurer loves all kinds of miracles and wizardry. In one wave of a magic wand he can turn an object into something else. But, as you all know, there is no better magic in the Universe than the magic of numbers. That's why Vasya adores math and spends a lot of time turning some numbers into some other ones.
This morning he has n cards with integers lined up in front of him. Each integer is not less than 1, but not greater than l. When Vasya waves his magic wand, two rightmost cards vanish from the line and a new card magically appears in their place. It contains the difference between the left and the right numbers on the two vanished cards. Vasya was very interested to know what would happen next, and so he waved with his magic wand on and on, until the table had a single card left.
Suppose that Vasya originally had the following cards: 4, 1, 1, 3 (listed from left to right). Then after the first wave the line would be: 4, 1, -2, and after the second one: 4, 3, and after the third one the table would have a single card with number 1.
Please note that in spite of the fact that initially all the numbers on the cards were not less than 1 and not greater than l, the numbers on the appearing cards can be anything, no restrictions are imposed on them.
It is now evening. Vasya is very tired and wants to return everything back, but does not remember which cards he had in the morning. He only remembers that there were n cards, they contained integers from 1 to l, and after all magical actions he was left with a single card containing number d.
Help Vasya to recover the initial set of cards with numbers.
Input
The single line contains three space-separated integers: n (2 ≤ n ≤ 100) — the initial number of cards on the table, d (|d| ≤ 104) — the number on the card that was left on the table after all the magical actions, and l (1 ≤ l ≤ 100) — the limits for the initial integers.
Output
If Vasya is mistaken, that is, if there doesn't exist a set that meets the requirements given in the statement, then print a single number -1, otherwise print the sought set containing n integers from 1 to l. Separate the integers by spaces. Print the integers in the order, in which they were written on the cards from left to right. If there are several suitable sets of numbers, you can print any of them.
Examples
Input
3 3 2
Output
2 1 2
Input
5 -4 3
Output
-1
Input
5 -4 4
Output
2 4 1 4 1
Submitted Solution:
```
#!/usr/bin/env python
from __future__ import division, print_function
import math
import os
import sys
from sys import stdin,stdout
from io import BytesIO, IOBase
from itertools import accumulate
from collections import deque
#sys.setrecursionlimit(10**5)
if sys.version_info[0] < 3:
from __builtin__ import xrange as range
from future_builtins import ascii, filter, hex, map, oct, zip
#sys.setrecursionlimit(10**6)
# region fastio
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")
def print(*args, **kwargs):
"""Prints the values to a stream, or to sys.stdout by default."""
sep, file = kwargs.pop("sep", " "), kwargs.pop("file", sys.stdout)
at_start = True
for x in args:
if not at_start:
file.write(sep)
file.write(str(x))
at_start = False
file.write(kwargs.pop("end", "\n"))
if kwargs.pop("flush", False):
file.flush()
if sys.version_info[0] < 3:
sys.stdin, sys.stdout = FastIO(sys.stdin), FastIO(sys.stdout)
else:
sys.stdin, sys.stdout = IOWrapper(sys.stdin), IOWrapper(sys.stdout)
input = lambda: sys.stdin.readline().rstrip("\r\n")
#-----------------------------------------------------------------
def regularbracket(t):
p=0
for i in t:
if i=="(":
p+=1
else:
p-=1
if p<0:
return False
else:
if p>0:
return False
else:
return True
#-------------------------------------------------
def binarySearchCount(arr, n, key):
left = 0
right = n - 1
count = 0
while (left <= right):
mid = int((right + left) / 2)
# Check if middle element is
# less than or equal to key
if (arr[mid] <= key):
count = mid+1
left = mid + 1
# If key is smaller, ignore right half
else:
right = mid - 1
return count
#------------------------------reverse string(pallindrome)
def reverse1(string):
pp=""
for i in string[::-1]:
pp+=i
if pp==string:
return True
return False
#--------------------------------reverse list(paindrome)
def reverse2(list1):
l=[]
for i in list1[::-1]:
l.append(i)
if l==list1:
return True
return False
def mex(list1):
#list1 = sorted(list1)
p = max(list1)+1
for i in range(len(list1)):
if list1[i]!=i:
p = i
break
return p
def sumofdigits(n):
n = str(n)
s1=0
for i in n:
s1+=int(i)
return s1
def perfect_square(n):
s = math.sqrt(n)
if s==int(s):
return True
return False
#print(perfect_square(16))
#endregion-------------------------------------------
def soretd(s):
for i in range(1,len(s)):
if s[i-1]>s[i]:
return False
return True
#print(soretd("1"))
def luckynumwithequalnumberoffourandseven(x,n,a):
if x >= n and str(x).count("4") == str(x).count("7"):
a.append(x)
else:
if x < 1e12:
luckynumwithequalnumberoffourandseven(x * 10 + 4,n,a)
luckynumwithequalnumberoffourandseven(x * 10 + 7,n,a)
return a
#endregio------------------------------
"""
def main():
t = int(input())
for _ in range(t):
n,m = map(int,input().split())
l=[]
ans=[]
p=[]
for i in range(m):
arr = list(map(int,input().split()))
arr.pop(0)
p.append(arr)
for j in arr:
l.append(j)
f = (m+1)//2
#print(p)
l = sorted(l)
sett = set(l)
sett = list(sett)
#print(sett)
for i in sett:
if l.count(i)<=f:
ans+=[i]*l.count(i)
else:
ans+=[i]*(f)
print(ans)
if len(ans)>=n:
print("YES")
for i in range(m):
for j in range(len(p[i])):
if p[i][j] in ans:
print(p[i][j],end=" ")
ans.remove(p[i][j])
break
print()
else:
print("NO")
if __name__ == '__main__':
main()
"""
"""
def main():
for _ in range(int(input())):
n=int(input())
arr = list(map(int,input().split()))
d = max(arr)
ans=0
if arr==sorted(arr):
print(0)
continue
# ind1 = arr.index(d)
for i in range(n-1):
if arr[i]>arr[i+1]:
ans+=(arr[i]-arr[i+1])
print(ans)
if __name__ == '__main__':
main()
"""
def main():
n,d,l = map(int,input().split())
ans=[]
c=0
for i in range(n-1):
if d>0:
c=l
else:
c=1
ans.append(c)
d = c-d
ans.append(d)
# print(ans)
for i in ans:
if i<1 or i>l:
print(-1)
break
else:
print(*ans)
if __name__ == '__main__':
main()
```
|
instruction
| 0
| 106,436
| 2
| 212,872
|
Yes
|
output
| 1
| 106,436
| 2
| 212,873
|
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
Vasya the Great Magician and Conjurer loves all kinds of miracles and wizardry. In one wave of a magic wand he can turn an object into something else. But, as you all know, there is no better magic in the Universe than the magic of numbers. That's why Vasya adores math and spends a lot of time turning some numbers into some other ones.
This morning he has n cards with integers lined up in front of him. Each integer is not less than 1, but not greater than l. When Vasya waves his magic wand, two rightmost cards vanish from the line and a new card magically appears in their place. It contains the difference between the left and the right numbers on the two vanished cards. Vasya was very interested to know what would happen next, and so he waved with his magic wand on and on, until the table had a single card left.
Suppose that Vasya originally had the following cards: 4, 1, 1, 3 (listed from left to right). Then after the first wave the line would be: 4, 1, -2, and after the second one: 4, 3, and after the third one the table would have a single card with number 1.
Please note that in spite of the fact that initially all the numbers on the cards were not less than 1 and not greater than l, the numbers on the appearing cards can be anything, no restrictions are imposed on them.
It is now evening. Vasya is very tired and wants to return everything back, but does not remember which cards he had in the morning. He only remembers that there were n cards, they contained integers from 1 to l, and after all magical actions he was left with a single card containing number d.
Help Vasya to recover the initial set of cards with numbers.
Input
The single line contains three space-separated integers: n (2 ≤ n ≤ 100) — the initial number of cards on the table, d (|d| ≤ 104) — the number on the card that was left on the table after all the magical actions, and l (1 ≤ l ≤ 100) — the limits for the initial integers.
Output
If Vasya is mistaken, that is, if there doesn't exist a set that meets the requirements given in the statement, then print a single number -1, otherwise print the sought set containing n integers from 1 to l. Separate the integers by spaces. Print the integers in the order, in which they were written on the cards from left to right. If there are several suitable sets of numbers, you can print any of them.
Examples
Input
3 3 2
Output
2 1 2
Input
5 -4 3
Output
-1
Input
5 -4 4
Output
2 4 1 4 1
Submitted Solution:
```
def modify(a, target, limit):
pos = sum([a[i] for i in range(len(a)) if i % 2 == 0])
neg = sum([a[i] for i in range(len(a)) if i % 2 == 1])
total = pos-neg
if total == target:
return a
if total < target:
diff = target-total
for i in range(len(a)):
if i % 2 == 0:
if limit-a[i] >= diff:
a[i] += diff
return a
else:
diff -= limit-a[i]
a[i] = limit
if diff > 0:
return None
else:
diff = total - target
for i in range(len(a)):
if i % 2 == 1:
if limit-a[i] >= diff:
a[i] += diff
return a
else:
diff -= limit-a[i]
a[i] = limit
if diff > 0:
return None
n, d, l = [int(i) for i in input().split()]
numbers = [1 for i in range(n)]
mod = modify(numbers, d, l)
if mod is None:
print(-1)
else:
print(" ".join([str(i) for i in mod]))
```
|
instruction
| 0
| 106,437
| 2
| 212,874
|
Yes
|
output
| 1
| 106,437
| 2
| 212,875
|
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
Vasya the Great Magician and Conjurer loves all kinds of miracles and wizardry. In one wave of a magic wand he can turn an object into something else. But, as you all know, there is no better magic in the Universe than the magic of numbers. That's why Vasya adores math and spends a lot of time turning some numbers into some other ones.
This morning he has n cards with integers lined up in front of him. Each integer is not less than 1, but not greater than l. When Vasya waves his magic wand, two rightmost cards vanish from the line and a new card magically appears in their place. It contains the difference between the left and the right numbers on the two vanished cards. Vasya was very interested to know what would happen next, and so he waved with his magic wand on and on, until the table had a single card left.
Suppose that Vasya originally had the following cards: 4, 1, 1, 3 (listed from left to right). Then after the first wave the line would be: 4, 1, -2, and after the second one: 4, 3, and after the third one the table would have a single card with number 1.
Please note that in spite of the fact that initially all the numbers on the cards were not less than 1 and not greater than l, the numbers on the appearing cards can be anything, no restrictions are imposed on them.
It is now evening. Vasya is very tired and wants to return everything back, but does not remember which cards he had in the morning. He only remembers that there were n cards, they contained integers from 1 to l, and after all magical actions he was left with a single card containing number d.
Help Vasya to recover the initial set of cards with numbers.
Input
The single line contains three space-separated integers: n (2 ≤ n ≤ 100) — the initial number of cards on the table, d (|d| ≤ 104) — the number on the card that was left on the table after all the magical actions, and l (1 ≤ l ≤ 100) — the limits for the initial integers.
Output
If Vasya is mistaken, that is, if there doesn't exist a set that meets the requirements given in the statement, then print a single number -1, otherwise print the sought set containing n integers from 1 to l. Separate the integers by spaces. Print the integers in the order, in which they were written on the cards from left to right. If there are several suitable sets of numbers, you can print any of them.
Examples
Input
3 3 2
Output
2 1 2
Input
5 -4 3
Output
-1
Input
5 -4 4
Output
2 4 1 4 1
Submitted Solution:
```
# x1-x2+x3...+/-xn = d and 1<=xi<=l for all i
# n d l
# 3 3 2 => x1-x2+x3=2 1<=xi<=3 1-1+2
# n is even x1-x2+...x(m-1)-xm=d
n,d,l=map(int,input().split())
m=(n//2)*(1-l)
M=(n//2)*(l-1)
if n%2!=0:
m+=1
M+=l
if not (m<=d<=M):
print(-1)
else:
e = d-m
l2=[1 if i%2==0 else l for i in range(n)]
ci=0
while e>0:
if ci%2==0:
l2[ci]+=min(l-1,e)
else:
l2[ci]-=min(l-1,e)
if ci+2<n:
ci+=2
else:
ci=1
e-=min(l-1,e)
for e in l2:
print(e,end=' ')
```
|
instruction
| 0
| 106,438
| 2
| 212,876
|
Yes
|
output
| 1
| 106,438
| 2
| 212,877
|
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
Vasya the Great Magician and Conjurer loves all kinds of miracles and wizardry. In one wave of a magic wand he can turn an object into something else. But, as you all know, there is no better magic in the Universe than the magic of numbers. That's why Vasya adores math and spends a lot of time turning some numbers into some other ones.
This morning he has n cards with integers lined up in front of him. Each integer is not less than 1, but not greater than l. When Vasya waves his magic wand, two rightmost cards vanish from the line and a new card magically appears in their place. It contains the difference between the left and the right numbers on the two vanished cards. Vasya was very interested to know what would happen next, and so he waved with his magic wand on and on, until the table had a single card left.
Suppose that Vasya originally had the following cards: 4, 1, 1, 3 (listed from left to right). Then after the first wave the line would be: 4, 1, -2, and after the second one: 4, 3, and after the third one the table would have a single card with number 1.
Please note that in spite of the fact that initially all the numbers on the cards were not less than 1 and not greater than l, the numbers on the appearing cards can be anything, no restrictions are imposed on them.
It is now evening. Vasya is very tired and wants to return everything back, but does not remember which cards he had in the morning. He only remembers that there were n cards, they contained integers from 1 to l, and after all magical actions he was left with a single card containing number d.
Help Vasya to recover the initial set of cards with numbers.
Input
The single line contains three space-separated integers: n (2 ≤ n ≤ 100) — the initial number of cards on the table, d (|d| ≤ 104) — the number on the card that was left on the table after all the magical actions, and l (1 ≤ l ≤ 100) — the limits for the initial integers.
Output
If Vasya is mistaken, that is, if there doesn't exist a set that meets the requirements given in the statement, then print a single number -1, otherwise print the sought set containing n integers from 1 to l. Separate the integers by spaces. Print the integers in the order, in which they were written on the cards from left to right. If there are several suitable sets of numbers, you can print any of them.
Examples
Input
3 3 2
Output
2 1 2
Input
5 -4 3
Output
-1
Input
5 -4 4
Output
2 4 1 4 1
Submitted Solution:
```
def magic(n, d, l):
ans = [d]
flag = 0
for i in range(n - 1):
temp = ans[i]
if temp < 1:
ans[i] = 1
ans.append(1 - temp)
else:
ans[i] = l
ans.append(l - temp)
if not 1 <= ans[n - 1] <= l:
flag = 1
if flag == 0:
return ans
else:
return -1
if __name__=="__main__":
n, d, l = map(int, input().split())
magic = magic(n, d, l)
if magic != -1:
for i in range(n):
print(magic[i], end=" ")
else:
print(-1)
```
|
instruction
| 0
| 106,439
| 2
| 212,878
|
Yes
|
output
| 1
| 106,439
| 2
| 212,879
|
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
Vasya the Great Magician and Conjurer loves all kinds of miracles and wizardry. In one wave of a magic wand he can turn an object into something else. But, as you all know, there is no better magic in the Universe than the magic of numbers. That's why Vasya adores math and spends a lot of time turning some numbers into some other ones.
This morning he has n cards with integers lined up in front of him. Each integer is not less than 1, but not greater than l. When Vasya waves his magic wand, two rightmost cards vanish from the line and a new card magically appears in their place. It contains the difference between the left and the right numbers on the two vanished cards. Vasya was very interested to know what would happen next, and so he waved with his magic wand on and on, until the table had a single card left.
Suppose that Vasya originally had the following cards: 4, 1, 1, 3 (listed from left to right). Then after the first wave the line would be: 4, 1, -2, and after the second one: 4, 3, and after the third one the table would have a single card with number 1.
Please note that in spite of the fact that initially all the numbers on the cards were not less than 1 and not greater than l, the numbers on the appearing cards can be anything, no restrictions are imposed on them.
It is now evening. Vasya is very tired and wants to return everything back, but does not remember which cards he had in the morning. He only remembers that there were n cards, they contained integers from 1 to l, and after all magical actions he was left with a single card containing number d.
Help Vasya to recover the initial set of cards with numbers.
Input
The single line contains three space-separated integers: n (2 ≤ n ≤ 100) — the initial number of cards on the table, d (|d| ≤ 104) — the number on the card that was left on the table after all the magical actions, and l (1 ≤ l ≤ 100) — the limits for the initial integers.
Output
If Vasya is mistaken, that is, if there doesn't exist a set that meets the requirements given in the statement, then print a single number -1, otherwise print the sought set containing n integers from 1 to l. Separate the integers by spaces. Print the integers in the order, in which they were written on the cards from left to right. If there are several suitable sets of numbers, you can print any of them.
Examples
Input
3 3 2
Output
2 1 2
Input
5 -4 3
Output
-1
Input
5 -4 4
Output
2 4 1 4 1
Submitted Solution:
```
### CLaim :
### With a starting L,n there is an upper and Lower boundary for the number u can get on the finaL card
### And u can get any number within this range
##
### To get the maximum or the minimum number :
### If the sequence incLudes onLy (1,L,1,L,1,L,...) depending on the number (n) even or odd and the starting number (either 1 or L)
### U wiLL get the maximum or the minimum
##
### If the input (d)<=0 use Gettable_minimum
### else use Gettable_maximum
##
##
def Gettable(x,L,n,c,Taken):
if(n==2):
if(x<=L-1 and x>=1-L):
if(x>=1):
return Taken+[L,L-x]
else:
return Taken+[1,1-x]
else:
return False
if(c=='1'):
x=1-x
m=Gettable(x,L,n-1,'L',Taken+[1])
if(m!=False):
return m
elif(c=='L'):
x=L-x
m=Gettable(x,L,n-1,'1',Taken+[L])
if(m!=False):
return m
else:
x=L-x
m=Gettable(x,L,n-1,'1',Taken+[L])
if(m!=False):
return m
x=1-x
m=Gettable(x,L,n-1,'L',Taken+[1])
if(m!=False):
return m
return False
n,d,l=map(int,input().split())
##
##if(d<=0):
## if( not Gettable_minimum(d,l,n) ):
## print(-1)
## else:
## Ans=[1]
## d=d
## while(len(Ans)<n):
## Ans.append(1-d)
if(n==2):
if(d in range(1-l,1)):
print(1,1-d)
elif(d in range(1,l)):
print(l,l-d)
else:
print(-1)
else:
Ans=Gettable(l-d,l,n-1,'1',[l])
if(Ans!=False):
for i in range(n-1):
print(Ans[i],end=" ")
print(Ans[-1])
else:
Ans=Gettable(1-d,l,n-1,'L',[1])
if(Ans!=False):
for i in range(n-1):
print(Ans[i],end=" ")
print(Ans[-1])
else:
print(-1)
```
|
instruction
| 0
| 106,440
| 2
| 212,880
|
No
|
output
| 1
| 106,440
| 2
| 212,881
|
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
Vasya the Great Magician and Conjurer loves all kinds of miracles and wizardry. In one wave of a magic wand he can turn an object into something else. But, as you all know, there is no better magic in the Universe than the magic of numbers. That's why Vasya adores math and spends a lot of time turning some numbers into some other ones.
This morning he has n cards with integers lined up in front of him. Each integer is not less than 1, but not greater than l. When Vasya waves his magic wand, two rightmost cards vanish from the line and a new card magically appears in their place. It contains the difference between the left and the right numbers on the two vanished cards. Vasya was very interested to know what would happen next, and so he waved with his magic wand on and on, until the table had a single card left.
Suppose that Vasya originally had the following cards: 4, 1, 1, 3 (listed from left to right). Then after the first wave the line would be: 4, 1, -2, and after the second one: 4, 3, and after the third one the table would have a single card with number 1.
Please note that in spite of the fact that initially all the numbers on the cards were not less than 1 and not greater than l, the numbers on the appearing cards can be anything, no restrictions are imposed on them.
It is now evening. Vasya is very tired and wants to return everything back, but does not remember which cards he had in the morning. He only remembers that there were n cards, they contained integers from 1 to l, and after all magical actions he was left with a single card containing number d.
Help Vasya to recover the initial set of cards with numbers.
Input
The single line contains three space-separated integers: n (2 ≤ n ≤ 100) — the initial number of cards on the table, d (|d| ≤ 104) — the number on the card that was left on the table after all the magical actions, and l (1 ≤ l ≤ 100) — the limits for the initial integers.
Output
If Vasya is mistaken, that is, if there doesn't exist a set that meets the requirements given in the statement, then print a single number -1, otherwise print the sought set containing n integers from 1 to l. Separate the integers by spaces. Print the integers in the order, in which they were written on the cards from left to right. If there are several suitable sets of numbers, you can print any of them.
Examples
Input
3 3 2
Output
2 1 2
Input
5 -4 3
Output
-1
Input
5 -4 4
Output
2 4 1 4 1
Submitted Solution:
```
n,d,l=map(int,input().split())
ans=[]
temp=0
for i in range(n-1):
if d>1:
ans.append(l)
temp=l
else:
ans.append(1)
temp=1
#print(d,temp-d)
d=temp-d
if d>=1 and d<=l:
ans.append(d)
print(*ans)
else:
print(-1)
```
|
instruction
| 0
| 106,441
| 2
| 212,882
|
No
|
output
| 1
| 106,441
| 2
| 212,883
|
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
Vasya the Great Magician and Conjurer loves all kinds of miracles and wizardry. In one wave of a magic wand he can turn an object into something else. But, as you all know, there is no better magic in the Universe than the magic of numbers. That's why Vasya adores math and spends a lot of time turning some numbers into some other ones.
This morning he has n cards with integers lined up in front of him. Each integer is not less than 1, but not greater than l. When Vasya waves his magic wand, two rightmost cards vanish from the line and a new card magically appears in their place. It contains the difference between the left and the right numbers on the two vanished cards. Vasya was very interested to know what would happen next, and so he waved with his magic wand on and on, until the table had a single card left.
Suppose that Vasya originally had the following cards: 4, 1, 1, 3 (listed from left to right). Then after the first wave the line would be: 4, 1, -2, and after the second one: 4, 3, and after the third one the table would have a single card with number 1.
Please note that in spite of the fact that initially all the numbers on the cards were not less than 1 and not greater than l, the numbers on the appearing cards can be anything, no restrictions are imposed on them.
It is now evening. Vasya is very tired and wants to return everything back, but does not remember which cards he had in the morning. He only remembers that there were n cards, they contained integers from 1 to l, and after all magical actions he was left with a single card containing number d.
Help Vasya to recover the initial set of cards with numbers.
Input
The single line contains three space-separated integers: n (2 ≤ n ≤ 100) — the initial number of cards on the table, d (|d| ≤ 104) — the number on the card that was left on the table after all the magical actions, and l (1 ≤ l ≤ 100) — the limits for the initial integers.
Output
If Vasya is mistaken, that is, if there doesn't exist a set that meets the requirements given in the statement, then print a single number -1, otherwise print the sought set containing n integers from 1 to l. Separate the integers by spaces. Print the integers in the order, in which they were written on the cards from left to right. If there are several suitable sets of numbers, you can print any of them.
Examples
Input
3 3 2
Output
2 1 2
Input
5 -4 3
Output
-1
Input
5 -4 4
Output
2 4 1 4 1
Submitted Solution:
```
nn=input()
a=[int(i) for i in nn.split()]
d=a[1]
l=a[2]
n=a[0]
oddn=int(n/2)+1
evenn=int(n/2)
a=[]
if d>(oddn*l-evenn) or d<(oddn-evenn*l):
print(-1)
else:
if n%2:
d-=1
for i in range(n):
a.append(int(1))
for i in range(n):
if i%2==0:
if d>0:
if d<l:
a[i]+=d
d-=d
else:
a[i]+=(l-1)
d-=(l-1)
else:
if d<0:
if d>(-l):
a[i]+=(-d)
d+=-d
else :
a[i]+=(l-1)
d+=(l-1)
for i in range(n):
print(a[i],end=" ")
```
|
instruction
| 0
| 106,442
| 2
| 212,884
|
No
|
output
| 1
| 106,442
| 2
| 212,885
|
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
Vasya the Great Magician and Conjurer loves all kinds of miracles and wizardry. In one wave of a magic wand he can turn an object into something else. But, as you all know, there is no better magic in the Universe than the magic of numbers. That's why Vasya adores math and spends a lot of time turning some numbers into some other ones.
This morning he has n cards with integers lined up in front of him. Each integer is not less than 1, but not greater than l. When Vasya waves his magic wand, two rightmost cards vanish from the line and a new card magically appears in their place. It contains the difference between the left and the right numbers on the two vanished cards. Vasya was very interested to know what would happen next, and so he waved with his magic wand on and on, until the table had a single card left.
Suppose that Vasya originally had the following cards: 4, 1, 1, 3 (listed from left to right). Then after the first wave the line would be: 4, 1, -2, and after the second one: 4, 3, and after the third one the table would have a single card with number 1.
Please note that in spite of the fact that initially all the numbers on the cards were not less than 1 and not greater than l, the numbers on the appearing cards can be anything, no restrictions are imposed on them.
It is now evening. Vasya is very tired and wants to return everything back, but does not remember which cards he had in the morning. He only remembers that there were n cards, they contained integers from 1 to l, and after all magical actions he was left with a single card containing number d.
Help Vasya to recover the initial set of cards with numbers.
Input
The single line contains three space-separated integers: n (2 ≤ n ≤ 100) — the initial number of cards on the table, d (|d| ≤ 104) — the number on the card that was left on the table after all the magical actions, and l (1 ≤ l ≤ 100) — the limits for the initial integers.
Output
If Vasya is mistaken, that is, if there doesn't exist a set that meets the requirements given in the statement, then print a single number -1, otherwise print the sought set containing n integers from 1 to l. Separate the integers by spaces. Print the integers in the order, in which they were written on the cards from left to right. If there are several suitable sets of numbers, you can print any of them.
Examples
Input
3 3 2
Output
2 1 2
Input
5 -4 3
Output
-1
Input
5 -4 4
Output
2 4 1 4 1
Submitted Solution:
```
### CLaim :
### With a starting L,n there is an upper and Lower boundary for the number u can get on the finaL card
### And u can get any number within this range
##
### To get the maximum or the minimum number :
### If the sequence incLudes onLy (1,L,1,L,1,L,...) depending on the number (n) even or odd and the starting number (either 1 or L)
### U wiLL get the maximum or the minimum
##
### If the input (d)<=0 use Gettable_minimum
### else use Gettable_maximum
##
##
def Gettable_maximum(d,L,n):
x=L-1
numbers_used=2
c=0
while(numbers_used<n):
if(c%2==0):
x=1-x
else:
x=L-x
c+=1
if(x>=d):
return True
numbers_used+=1
numbers_used=2
x=1-L
c=1
while(numbers_used<n):
if(c%2==0):
x=1-x
else:
x=L-x
c+=1
if(x>=d):
return True
numbers_used+=1
return False
def Gettable_minimum(d,L,n):
x=L-1
numbers_used=2
c=0
while(numbers_used<n):
if(c%2==0):
x=1-x
else:
x=L-x
c+=1
if(x<=d):
return True
numbers_used+=1
numbers_used=2
x=1-L
c=1
while(numbers_used<n):
if(c%2==0):
x=1-x
else:
x=L-x
c+=1
if(x<=d):
return True
numbers_used+=1
return False
##
n,d,l=map(int,input().split())
##
##if(d<=0):
## if( not Gettable_minimum(d,l,n) ):
## print(-1)
## else:
## Ans=[1]
## d=d
## while(len(Ans)<n):
## Ans.append(1-d)
Ans=[]
done=False
if(d>l and not Gettable_maximum(d,l,n)):
print(-1)
elif(d<=0 and not Gettable_minimum(d,l,n)):
print(-1)
else:
while(len(Ans)<n):
if(d<=0):
Ans.append(1)
d=1-d
elif(d>l):
Ans.append(l)
d=l-d
elif(len(Ans)!=n-2):
Ans.append(l)
d=l-d
else:
Ans.append(l)
Ans.append(l-d)
for i in range(n-1):
print(Ans[i],end=" ")
print(Ans[-1])
```
|
instruction
| 0
| 106,443
| 2
| 212,886
|
No
|
output
| 1
| 106,443
| 2
| 212,887
|
Provide tags and a correct Python 3 solution for this coding contest problem.
Nian is a monster which lives deep in the oceans. Once a year, it shows up on the land, devouring livestock and even people. In order to keep the monster away, people fill their villages with red colour, light, and cracking noise, all of which frighten the monster out of coming.
Little Tommy has n lanterns and Big Banban has m lanterns. Tommy's lanterns have brightness a1, a2, ..., an, and Banban's have brightness b1, b2, ..., bm respectively.
Tommy intends to hide one of his lanterns, then Banban picks one of Tommy's non-hidden lanterns and one of his own lanterns to form a pair. The pair's brightness will be the product of the brightness of two lanterns.
Tommy wants to make the product as small as possible, while Banban tries to make it as large as possible.
You are asked to find the brightness of the chosen pair if both of them choose optimally.
Input
The first line contains two space-separated integers n and m (2 ≤ n, m ≤ 50).
The second line contains n space-separated integers a1, a2, ..., an.
The third line contains m space-separated integers b1, b2, ..., bm.
All the integers range from - 109 to 109.
Output
Print a single integer — the brightness of the chosen pair.
Examples
Input
2 2
20 18
2 14
Output
252
Input
5 3
-1 0 1 2 3
-1 0 1
Output
2
Note
In the first example, Tommy will hide 20 and Banban will choose 18 from Tommy and 14 from himself.
In the second example, Tommy will hide 3 and Banban will choose 2 from Tommy and 1 from himself.
|
instruction
| 0
| 106,737
| 2
| 213,474
|
Tags: brute force, games
Correct Solution:
```
n,m=map(int,input().split())
a=list(map(int,input().split()))
b=list(map(int,input().split()))
res=[[max(a1*b1 for b1 in b)]for a1 in a]
res.sort()
print(res[-2][0])
```
|
output
| 1
| 106,737
| 2
| 213,475
|
Provide tags and a correct Python 3 solution for this coding contest problem.
Nian is a monster which lives deep in the oceans. Once a year, it shows up on the land, devouring livestock and even people. In order to keep the monster away, people fill their villages with red colour, light, and cracking noise, all of which frighten the monster out of coming.
Little Tommy has n lanterns and Big Banban has m lanterns. Tommy's lanterns have brightness a1, a2, ..., an, and Banban's have brightness b1, b2, ..., bm respectively.
Tommy intends to hide one of his lanterns, then Banban picks one of Tommy's non-hidden lanterns and one of his own lanterns to form a pair. The pair's brightness will be the product of the brightness of two lanterns.
Tommy wants to make the product as small as possible, while Banban tries to make it as large as possible.
You are asked to find the brightness of the chosen pair if both of them choose optimally.
Input
The first line contains two space-separated integers n and m (2 ≤ n, m ≤ 50).
The second line contains n space-separated integers a1, a2, ..., an.
The third line contains m space-separated integers b1, b2, ..., bm.
All the integers range from - 109 to 109.
Output
Print a single integer — the brightness of the chosen pair.
Examples
Input
2 2
20 18
2 14
Output
252
Input
5 3
-1 0 1 2 3
-1 0 1
Output
2
Note
In the first example, Tommy will hide 20 and Banban will choose 18 from Tommy and 14 from himself.
In the second example, Tommy will hide 3 and Banban will choose 2 from Tommy and 1 from himself.
|
instruction
| 0
| 106,738
| 2
| 213,476
|
Tags: brute force, games
Correct Solution:
```
n, m = map(int, input().split())
a = list(map(int, input().split()))
b = list(map(int, input().split()))
print(min([max([max([a[j]*k for k in b]) for j in range(n) if j!=i]) for i in range(n)]))
```
|
output
| 1
| 106,738
| 2
| 213,477
|
Provide tags and a correct Python 3 solution for this coding contest problem.
Nian is a monster which lives deep in the oceans. Once a year, it shows up on the land, devouring livestock and even people. In order to keep the monster away, people fill their villages with red colour, light, and cracking noise, all of which frighten the monster out of coming.
Little Tommy has n lanterns and Big Banban has m lanterns. Tommy's lanterns have brightness a1, a2, ..., an, and Banban's have brightness b1, b2, ..., bm respectively.
Tommy intends to hide one of his lanterns, then Banban picks one of Tommy's non-hidden lanterns and one of his own lanterns to form a pair. The pair's brightness will be the product of the brightness of two lanterns.
Tommy wants to make the product as small as possible, while Banban tries to make it as large as possible.
You are asked to find the brightness of the chosen pair if both of them choose optimally.
Input
The first line contains two space-separated integers n and m (2 ≤ n, m ≤ 50).
The second line contains n space-separated integers a1, a2, ..., an.
The third line contains m space-separated integers b1, b2, ..., bm.
All the integers range from - 109 to 109.
Output
Print a single integer — the brightness of the chosen pair.
Examples
Input
2 2
20 18
2 14
Output
252
Input
5 3
-1 0 1 2 3
-1 0 1
Output
2
Note
In the first example, Tommy will hide 20 and Banban will choose 18 from Tommy and 14 from himself.
In the second example, Tommy will hide 3 and Banban will choose 2 from Tommy and 1 from himself.
|
instruction
| 0
| 106,739
| 2
| 213,478
|
Tags: brute force, games
Correct Solution:
```
m=[int(i) for i in input().split()]
a= [int(i) for i in input().split()]
b= [int(i) for i in input().split()]
r =[[max(ax*bx for bx in b)] for ax in a]
r.sort()
print (int(r[-2][0]))
```
|
output
| 1
| 106,739
| 2
| 213,479
|
Provide tags and a correct Python 3 solution for this coding contest problem.
Nian is a monster which lives deep in the oceans. Once a year, it shows up on the land, devouring livestock and even people. In order to keep the monster away, people fill their villages with red colour, light, and cracking noise, all of which frighten the monster out of coming.
Little Tommy has n lanterns and Big Banban has m lanterns. Tommy's lanterns have brightness a1, a2, ..., an, and Banban's have brightness b1, b2, ..., bm respectively.
Tommy intends to hide one of his lanterns, then Banban picks one of Tommy's non-hidden lanterns and one of his own lanterns to form a pair. The pair's brightness will be the product of the brightness of two lanterns.
Tommy wants to make the product as small as possible, while Banban tries to make it as large as possible.
You are asked to find the brightness of the chosen pair if both of them choose optimally.
Input
The first line contains two space-separated integers n and m (2 ≤ n, m ≤ 50).
The second line contains n space-separated integers a1, a2, ..., an.
The third line contains m space-separated integers b1, b2, ..., bm.
All the integers range from - 109 to 109.
Output
Print a single integer — the brightness of the chosen pair.
Examples
Input
2 2
20 18
2 14
Output
252
Input
5 3
-1 0 1 2 3
-1 0 1
Output
2
Note
In the first example, Tommy will hide 20 and Banban will choose 18 from Tommy and 14 from himself.
In the second example, Tommy will hide 3 and Banban will choose 2 from Tommy and 1 from himself.
|
instruction
| 0
| 106,740
| 2
| 213,480
|
Tags: brute force, games
Correct Solution:
```
def main():
n, m = [int(x) for x in input().split()]
a = sorted([int(x) for x in input().split()])
b = sorted([int(x) for x in input().split()])
vv = max(a[0] * b[0], a[-1]* b[0], a[0]*b[-1],a[-1]*b[-1])
if vv == a[0] * b[0] or vv == a[0]*b[-1]:
a.pop(0)
else:
a.pop(-1)
vv = max(a[0] * b[0], a[-1]* b[0], a[0]*b[-1],a[-1]*b[-1])
print(vv)
if __name__ == '__main__':
main()
```
|
output
| 1
| 106,740
| 2
| 213,481
|
Provide tags and a correct Python 3 solution for this coding contest problem.
Nian is a monster which lives deep in the oceans. Once a year, it shows up on the land, devouring livestock and even people. In order to keep the monster away, people fill their villages with red colour, light, and cracking noise, all of which frighten the monster out of coming.
Little Tommy has n lanterns and Big Banban has m lanterns. Tommy's lanterns have brightness a1, a2, ..., an, and Banban's have brightness b1, b2, ..., bm respectively.
Tommy intends to hide one of his lanterns, then Banban picks one of Tommy's non-hidden lanterns and one of his own lanterns to form a pair. The pair's brightness will be the product of the brightness of two lanterns.
Tommy wants to make the product as small as possible, while Banban tries to make it as large as possible.
You are asked to find the brightness of the chosen pair if both of them choose optimally.
Input
The first line contains two space-separated integers n and m (2 ≤ n, m ≤ 50).
The second line contains n space-separated integers a1, a2, ..., an.
The third line contains m space-separated integers b1, b2, ..., bm.
All the integers range from - 109 to 109.
Output
Print a single integer — the brightness of the chosen pair.
Examples
Input
2 2
20 18
2 14
Output
252
Input
5 3
-1 0 1 2 3
-1 0 1
Output
2
Note
In the first example, Tommy will hide 20 and Banban will choose 18 from Tommy and 14 from himself.
In the second example, Tommy will hide 3 and Banban will choose 2 from Tommy and 1 from himself.
|
instruction
| 0
| 106,741
| 2
| 213,482
|
Tags: brute force, games
Correct Solution:
```
#!/usr/bin/env python3
# -*- coding: utf-8 -*-
import array
from bisect import *
from collections import *
import fractions
import heapq
from itertools import *
import math
import random
import re
import string
N, M = map(int, input().split())
A = list(map(int, input().split()))
B = list(map(int, input().split()))
A.sort()
B.sort()
ans = 1e20
for i in range(N):
A2 = A[:i] + A[i+1:]
local_ans = -1e20
for a in A2:
for b in B:
local_ans = max(local_ans, a * b)
# print(A2, B)
# print("local_ans:", local_ans)
ans = min(ans, local_ans)
print(ans)
```
|
output
| 1
| 106,741
| 2
| 213,483
|
Provide tags and a correct Python 3 solution for this coding contest problem.
Nian is a monster which lives deep in the oceans. Once a year, it shows up on the land, devouring livestock and even people. In order to keep the monster away, people fill their villages with red colour, light, and cracking noise, all of which frighten the monster out of coming.
Little Tommy has n lanterns and Big Banban has m lanterns. Tommy's lanterns have brightness a1, a2, ..., an, and Banban's have brightness b1, b2, ..., bm respectively.
Tommy intends to hide one of his lanterns, then Banban picks one of Tommy's non-hidden lanterns and one of his own lanterns to form a pair. The pair's brightness will be the product of the brightness of two lanterns.
Tommy wants to make the product as small as possible, while Banban tries to make it as large as possible.
You are asked to find the brightness of the chosen pair if both of them choose optimally.
Input
The first line contains two space-separated integers n and m (2 ≤ n, m ≤ 50).
The second line contains n space-separated integers a1, a2, ..., an.
The third line contains m space-separated integers b1, b2, ..., bm.
All the integers range from - 109 to 109.
Output
Print a single integer — the brightness of the chosen pair.
Examples
Input
2 2
20 18
2 14
Output
252
Input
5 3
-1 0 1 2 3
-1 0 1
Output
2
Note
In the first example, Tommy will hide 20 and Banban will choose 18 from Tommy and 14 from himself.
In the second example, Tommy will hide 3 and Banban will choose 2 from Tommy and 1 from himself.
|
instruction
| 0
| 106,742
| 2
| 213,484
|
Tags: brute force, games
Correct Solution:
```
def main():
n, m = list(map(int, input().split()))
t = list(map(int, input().split()))
b = list(map(int, input().split()))
maxs = []
for ex in range(len(t)):
maxs.append(max(x * y for i, x in enumerate(t) for y in b if i != ex))
print(min(maxs))
if __name__ == '__main__':
main()
```
|
output
| 1
| 106,742
| 2
| 213,485
|
Provide tags and a correct Python 3 solution for this coding contest problem.
Nian is a monster which lives deep in the oceans. Once a year, it shows up on the land, devouring livestock and even people. In order to keep the monster away, people fill their villages with red colour, light, and cracking noise, all of which frighten the monster out of coming.
Little Tommy has n lanterns and Big Banban has m lanterns. Tommy's lanterns have brightness a1, a2, ..., an, and Banban's have brightness b1, b2, ..., bm respectively.
Tommy intends to hide one of his lanterns, then Banban picks one of Tommy's non-hidden lanterns and one of his own lanterns to form a pair. The pair's brightness will be the product of the brightness of two lanterns.
Tommy wants to make the product as small as possible, while Banban tries to make it as large as possible.
You are asked to find the brightness of the chosen pair if both of them choose optimally.
Input
The first line contains two space-separated integers n and m (2 ≤ n, m ≤ 50).
The second line contains n space-separated integers a1, a2, ..., an.
The third line contains m space-separated integers b1, b2, ..., bm.
All the integers range from - 109 to 109.
Output
Print a single integer — the brightness of the chosen pair.
Examples
Input
2 2
20 18
2 14
Output
252
Input
5 3
-1 0 1 2 3
-1 0 1
Output
2
Note
In the first example, Tommy will hide 20 and Banban will choose 18 from Tommy and 14 from himself.
In the second example, Tommy will hide 3 and Banban will choose 2 from Tommy and 1 from himself.
|
instruction
| 0
| 106,743
| 2
| 213,486
|
Tags: brute force, games
Correct Solution:
```
n,m = map(int,input().split())
l1 = [int(x) for x in input().split()]
l2 = [int(x) for x in input().split()]
r = [[max(a*b for b in l2)] for a in l1]
r.sort()
print(r[-2][0])
```
|
output
| 1
| 106,743
| 2
| 213,487
|
Provide tags and a correct Python 3 solution for this coding contest problem.
Nian is a monster which lives deep in the oceans. Once a year, it shows up on the land, devouring livestock and even people. In order to keep the monster away, people fill their villages with red colour, light, and cracking noise, all of which frighten the monster out of coming.
Little Tommy has n lanterns and Big Banban has m lanterns. Tommy's lanterns have brightness a1, a2, ..., an, and Banban's have brightness b1, b2, ..., bm respectively.
Tommy intends to hide one of his lanterns, then Banban picks one of Tommy's non-hidden lanterns and one of his own lanterns to form a pair. The pair's brightness will be the product of the brightness of two lanterns.
Tommy wants to make the product as small as possible, while Banban tries to make it as large as possible.
You are asked to find the brightness of the chosen pair if both of them choose optimally.
Input
The first line contains two space-separated integers n and m (2 ≤ n, m ≤ 50).
The second line contains n space-separated integers a1, a2, ..., an.
The third line contains m space-separated integers b1, b2, ..., bm.
All the integers range from - 109 to 109.
Output
Print a single integer — the brightness of the chosen pair.
Examples
Input
2 2
20 18
2 14
Output
252
Input
5 3
-1 0 1 2 3
-1 0 1
Output
2
Note
In the first example, Tommy will hide 20 and Banban will choose 18 from Tommy and 14 from himself.
In the second example, Tommy will hide 3 and Banban will choose 2 from Tommy and 1 from himself.
|
instruction
| 0
| 106,744
| 2
| 213,488
|
Tags: brute force, games
Correct Solution:
```
#!/usr/bin/env python
import os
import sys
from io import BytesIO, IOBase
#from bisect import bisect_left as bl #c++ lowerbound bl(array,element)
#from bisect import bisect_right as br #c++ upperbound br(array,element)
def main():
n,m=map(int,input().split(" "))
a=list(map(int,input().split(" ")))
b=list(map(int,input().split(" ")))
temp=[]
mxhidden=-(1e100)
hid=0
for y in range(m):
for z in range(n):
if b[y]*a[z]>mxhidden:
mxhidden=b[y]*a[z]
hid=z
#print(mxhidden,y)
a.pop(hid)
ans=(-1e100)
for x in range(n-1):
for y in range(m):
ans=max(ans,a[x]*b[y])
print(ans)
#-----------------------------BOSS-------------------------------------!
# region fastio
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")
# endregion
if __name__ == "__main__":
main()
```
|
output
| 1
| 106,744
| 2
| 213,489
|
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
Nian is a monster which lives deep in the oceans. Once a year, it shows up on the land, devouring livestock and even people. In order to keep the monster away, people fill their villages with red colour, light, and cracking noise, all of which frighten the monster out of coming.
Little Tommy has n lanterns and Big Banban has m lanterns. Tommy's lanterns have brightness a1, a2, ..., an, and Banban's have brightness b1, b2, ..., bm respectively.
Tommy intends to hide one of his lanterns, then Banban picks one of Tommy's non-hidden lanterns and one of his own lanterns to form a pair. The pair's brightness will be the product of the brightness of two lanterns.
Tommy wants to make the product as small as possible, while Banban tries to make it as large as possible.
You are asked to find the brightness of the chosen pair if both of them choose optimally.
Input
The first line contains two space-separated integers n and m (2 ≤ n, m ≤ 50).
The second line contains n space-separated integers a1, a2, ..., an.
The third line contains m space-separated integers b1, b2, ..., bm.
All the integers range from - 109 to 109.
Output
Print a single integer — the brightness of the chosen pair.
Examples
Input
2 2
20 18
2 14
Output
252
Input
5 3
-1 0 1 2 3
-1 0 1
Output
2
Note
In the first example, Tommy will hide 20 and Banban will choose 18 from Tommy and 14 from himself.
In the second example, Tommy will hide 3 and Banban will choose 2 from Tommy and 1 from himself.
Submitted Solution:
```
n,m=map(int, input().split())
a=list(map(int, input().split()))
b=list(map(int, input().split()))
ans=float('inf')
for i in range(n):
now=-float('inf')
for j in range(n):
if j!=i:
for k in range(m):
now=max(now,a[j]*b[k])
ans=min(ans,now)
print(ans)
```
|
instruction
| 0
| 106,745
| 2
| 213,490
|
Yes
|
output
| 1
| 106,745
| 2
| 213,491
|
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
Nian is a monster which lives deep in the oceans. Once a year, it shows up on the land, devouring livestock and even people. In order to keep the monster away, people fill their villages with red colour, light, and cracking noise, all of which frighten the monster out of coming.
Little Tommy has n lanterns and Big Banban has m lanterns. Tommy's lanterns have brightness a1, a2, ..., an, and Banban's have brightness b1, b2, ..., bm respectively.
Tommy intends to hide one of his lanterns, then Banban picks one of Tommy's non-hidden lanterns and one of his own lanterns to form a pair. The pair's brightness will be the product of the brightness of two lanterns.
Tommy wants to make the product as small as possible, while Banban tries to make it as large as possible.
You are asked to find the brightness of the chosen pair if both of them choose optimally.
Input
The first line contains two space-separated integers n and m (2 ≤ n, m ≤ 50).
The second line contains n space-separated integers a1, a2, ..., an.
The third line contains m space-separated integers b1, b2, ..., bm.
All the integers range from - 109 to 109.
Output
Print a single integer — the brightness of the chosen pair.
Examples
Input
2 2
20 18
2 14
Output
252
Input
5 3
-1 0 1 2 3
-1 0 1
Output
2
Note
In the first example, Tommy will hide 20 and Banban will choose 18 from Tommy and 14 from himself.
In the second example, Tommy will hide 3 and Banban will choose 2 from Tommy and 1 from himself.
Submitted Solution:
```
n,m = map(int, input().split())
A = list(map(int, input().split()))
B = list(map(int, input().split()))
ans1 = float('inf')
for i in range(n):
ans2 = -float('inf')
for j in range(n):
if j == i:
continue
for k in range(m):
ans2 = max(ans2, A[j]*B[k])
ans1 = min(ans1, ans2)
print(ans1)
```
|
instruction
| 0
| 106,746
| 2
| 213,492
|
Yes
|
output
| 1
| 106,746
| 2
| 213,493
|
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
Nian is a monster which lives deep in the oceans. Once a year, it shows up on the land, devouring livestock and even people. In order to keep the monster away, people fill their villages with red colour, light, and cracking noise, all of which frighten the monster out of coming.
Little Tommy has n lanterns and Big Banban has m lanterns. Tommy's lanterns have brightness a1, a2, ..., an, and Banban's have brightness b1, b2, ..., bm respectively.
Tommy intends to hide one of his lanterns, then Banban picks one of Tommy's non-hidden lanterns and one of his own lanterns to form a pair. The pair's brightness will be the product of the brightness of two lanterns.
Tommy wants to make the product as small as possible, while Banban tries to make it as large as possible.
You are asked to find the brightness of the chosen pair if both of them choose optimally.
Input
The first line contains two space-separated integers n and m (2 ≤ n, m ≤ 50).
The second line contains n space-separated integers a1, a2, ..., an.
The third line contains m space-separated integers b1, b2, ..., bm.
All the integers range from - 109 to 109.
Output
Print a single integer — the brightness of the chosen pair.
Examples
Input
2 2
20 18
2 14
Output
252
Input
5 3
-1 0 1 2 3
-1 0 1
Output
2
Note
In the first example, Tommy will hide 20 and Banban will choose 18 from Tommy and 14 from himself.
In the second example, Tommy will hide 3 and Banban will choose 2 from Tommy and 1 from himself.
Submitted Solution:
```
n, m = [int(x) for x in input().split()]
a = [int(x) for x in input().split()]
b = [int(x) for x in input().split()]
b.sort()
first = []
for x in a:
if x > 0:
first.append(x*b[-1])
elif x<0:
first.append(x*b[0])
else:
first.append(0)
ans = 10**25
for i in range(len(a)):
s = -10**25
for j in range(len(a)):
if j!=i:
if first[j]>s: s=first[j]
if s < ans: ans=s
print(ans)
```
|
instruction
| 0
| 106,747
| 2
| 213,494
|
Yes
|
output
| 1
| 106,747
| 2
| 213,495
|
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
Nian is a monster which lives deep in the oceans. Once a year, it shows up on the land, devouring livestock and even people. In order to keep the monster away, people fill their villages with red colour, light, and cracking noise, all of which frighten the monster out of coming.
Little Tommy has n lanterns and Big Banban has m lanterns. Tommy's lanterns have brightness a1, a2, ..., an, and Banban's have brightness b1, b2, ..., bm respectively.
Tommy intends to hide one of his lanterns, then Banban picks one of Tommy's non-hidden lanterns and one of his own lanterns to form a pair. The pair's brightness will be the product of the brightness of two lanterns.
Tommy wants to make the product as small as possible, while Banban tries to make it as large as possible.
You are asked to find the brightness of the chosen pair if both of them choose optimally.
Input
The first line contains two space-separated integers n and m (2 ≤ n, m ≤ 50).
The second line contains n space-separated integers a1, a2, ..., an.
The third line contains m space-separated integers b1, b2, ..., bm.
All the integers range from - 109 to 109.
Output
Print a single integer — the brightness of the chosen pair.
Examples
Input
2 2
20 18
2 14
Output
252
Input
5 3
-1 0 1 2 3
-1 0 1
Output
2
Note
In the first example, Tommy will hide 20 and Banban will choose 18 from Tommy and 14 from himself.
In the second example, Tommy will hide 3 and Banban will choose 2 from Tommy and 1 from himself.
Submitted Solution:
```
n, m = [int(x) for x in input().split()]
a = [int(x) for x in input().split()]
b = [int(x) for x in input().split()]
res = [max([ax*bx for bx in b]) for ax in a]
res.sort(reverse=True)
print(res[1])
```
|
instruction
| 0
| 106,748
| 2
| 213,496
|
Yes
|
output
| 1
| 106,748
| 2
| 213,497
|
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
Nian is a monster which lives deep in the oceans. Once a year, it shows up on the land, devouring livestock and even people. In order to keep the monster away, people fill their villages with red colour, light, and cracking noise, all of which frighten the monster out of coming.
Little Tommy has n lanterns and Big Banban has m lanterns. Tommy's lanterns have brightness a1, a2, ..., an, and Banban's have brightness b1, b2, ..., bm respectively.
Tommy intends to hide one of his lanterns, then Banban picks one of Tommy's non-hidden lanterns and one of his own lanterns to form a pair. The pair's brightness will be the product of the brightness of two lanterns.
Tommy wants to make the product as small as possible, while Banban tries to make it as large as possible.
You are asked to find the brightness of the chosen pair if both of them choose optimally.
Input
The first line contains two space-separated integers n and m (2 ≤ n, m ≤ 50).
The second line contains n space-separated integers a1, a2, ..., an.
The third line contains m space-separated integers b1, b2, ..., bm.
All the integers range from - 109 to 109.
Output
Print a single integer — the brightness of the chosen pair.
Examples
Input
2 2
20 18
2 14
Output
252
Input
5 3
-1 0 1 2 3
-1 0 1
Output
2
Note
In the first example, Tommy will hide 20 and Banban will choose 18 from Tommy and 14 from himself.
In the second example, Tommy will hide 3 and Banban will choose 2 from Tommy and 1 from himself.
Submitted Solution:
```
n, k = map(int, input().split())
ar = [int(p) for p in input().split()]
arr = [int(p) for p in input().split()]
ar = list(set(ar))
m = max(ar)
if m < 0:
m = min(ar)
ar.pop(ar.index(m))
maxim = -10000000000
for i in range(len(ar)):
for j in range(k):
tmp = ar[i]*arr[j]
if tmp > maxim:
maxim = tmp
print(maxim)
```
|
instruction
| 0
| 106,749
| 2
| 213,498
|
No
|
output
| 1
| 106,749
| 2
| 213,499
|
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
Nian is a monster which lives deep in the oceans. Once a year, it shows up on the land, devouring livestock and even people. In order to keep the monster away, people fill their villages with red colour, light, and cracking noise, all of which frighten the monster out of coming.
Little Tommy has n lanterns and Big Banban has m lanterns. Tommy's lanterns have brightness a1, a2, ..., an, and Banban's have brightness b1, b2, ..., bm respectively.
Tommy intends to hide one of his lanterns, then Banban picks one of Tommy's non-hidden lanterns and one of his own lanterns to form a pair. The pair's brightness will be the product of the brightness of two lanterns.
Tommy wants to make the product as small as possible, while Banban tries to make it as large as possible.
You are asked to find the brightness of the chosen pair if both of them choose optimally.
Input
The first line contains two space-separated integers n and m (2 ≤ n, m ≤ 50).
The second line contains n space-separated integers a1, a2, ..., an.
The third line contains m space-separated integers b1, b2, ..., bm.
All the integers range from - 109 to 109.
Output
Print a single integer — the brightness of the chosen pair.
Examples
Input
2 2
20 18
2 14
Output
252
Input
5 3
-1 0 1 2 3
-1 0 1
Output
2
Note
In the first example, Tommy will hide 20 and Banban will choose 18 from Tommy and 14 from himself.
In the second example, Tommy will hide 3 and Banban will choose 2 from Tommy and 1 from himself.
Submitted Solution:
```
nm=input().split()
n=input().split()
m=input().split()
MAXn=-1000000000
MAXm=-1000000000
for i in n:
i=int(i)
if i>=MAXn:
MAXn=i
for i in m:
i=int(i)
if i>=MAXm:
MAXm=i
for i in n:
i=int(i)
if MAXn==i:
n.remove(str(i))
MAXn=-100000000
for i in n:
i=int(i)
if i>=MAXn:
MAXn=i
print(MAXm*MAXn)
```
|
instruction
| 0
| 106,750
| 2
| 213,500
|
No
|
output
| 1
| 106,750
| 2
| 213,501
|
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
Nian is a monster which lives deep in the oceans. Once a year, it shows up on the land, devouring livestock and even people. In order to keep the monster away, people fill their villages with red colour, light, and cracking noise, all of which frighten the monster out of coming.
Little Tommy has n lanterns and Big Banban has m lanterns. Tommy's lanterns have brightness a1, a2, ..., an, and Banban's have brightness b1, b2, ..., bm respectively.
Tommy intends to hide one of his lanterns, then Banban picks one of Tommy's non-hidden lanterns and one of his own lanterns to form a pair. The pair's brightness will be the product of the brightness of two lanterns.
Tommy wants to make the product as small as possible, while Banban tries to make it as large as possible.
You are asked to find the brightness of the chosen pair if both of them choose optimally.
Input
The first line contains two space-separated integers n and m (2 ≤ n, m ≤ 50).
The second line contains n space-separated integers a1, a2, ..., an.
The third line contains m space-separated integers b1, b2, ..., bm.
All the integers range from - 109 to 109.
Output
Print a single integer — the brightness of the chosen pair.
Examples
Input
2 2
20 18
2 14
Output
252
Input
5 3
-1 0 1 2 3
-1 0 1
Output
2
Note
In the first example, Tommy will hide 20 and Banban will choose 18 from Tommy and 14 from himself.
In the second example, Tommy will hide 3 and Banban will choose 2 from Tommy and 1 from himself.
Submitted Solution:
```
n, m=map(int, input().split())
a=sorted(list(map(int, input().split())))
b=sorted(list(map(int, input().split())))
if a[0]*b[0] > a[-1]*b[-1]:
a = a[1:]
else:
a = a[:-1]
print(max(a[-1]*b[-1], a[0]*b[0]))
```
|
instruction
| 0
| 106,751
| 2
| 213,502
|
No
|
output
| 1
| 106,751
| 2
| 213,503
|
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
Nian is a monster which lives deep in the oceans. Once a year, it shows up on the land, devouring livestock and even people. In order to keep the monster away, people fill their villages with red colour, light, and cracking noise, all of which frighten the monster out of coming.
Little Tommy has n lanterns and Big Banban has m lanterns. Tommy's lanterns have brightness a1, a2, ..., an, and Banban's have brightness b1, b2, ..., bm respectively.
Tommy intends to hide one of his lanterns, then Banban picks one of Tommy's non-hidden lanterns and one of his own lanterns to form a pair. The pair's brightness will be the product of the brightness of two lanterns.
Tommy wants to make the product as small as possible, while Banban tries to make it as large as possible.
You are asked to find the brightness of the chosen pair if both of them choose optimally.
Input
The first line contains two space-separated integers n and m (2 ≤ n, m ≤ 50).
The second line contains n space-separated integers a1, a2, ..., an.
The third line contains m space-separated integers b1, b2, ..., bm.
All the integers range from - 109 to 109.
Output
Print a single integer — the brightness of the chosen pair.
Examples
Input
2 2
20 18
2 14
Output
252
Input
5 3
-1 0 1 2 3
-1 0 1
Output
2
Note
In the first example, Tommy will hide 20 and Banban will choose 18 from Tommy and 14 from himself.
In the second example, Tommy will hide 3 and Banban will choose 2 from Tommy and 1 from himself.
Submitted Solution:
```
s = input().split()
s1 = input().split()
s2 = input().split()
n = int(s[0])
m = int(s[1])
list2 = []
list1 = []
for i in s1:
list1.append(int(i))
for i in s2:
list2.append(int(i))
list1.sort()
list2.sort()
cl = []
for i in list1:
for j in list2:
cl.append(i*j)
cl.sort()
print(cl[n*m-2])
```
|
instruction
| 0
| 106,752
| 2
| 213,504
|
No
|
output
| 1
| 106,752
| 2
| 213,505
|
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
Princess Twilight went to Celestia and Luna's old castle to research the chest from the Elements of Harmony.
<image>
A sequence of positive integers bi is harmony if and only if for every two elements of the sequence their greatest common divisor equals 1. According to an ancient book, the key of the chest is a harmony sequence bi which minimizes the following expression:
<image>
You are given sequence ai, help Princess Twilight to find the key.
Input
The first line contains an integer n (1 ≤ n ≤ 100) — the number of elements of the sequences a and b. The next line contains n integers a1, a2, ..., an (1 ≤ ai ≤ 30).
Output
Output the key — sequence bi that minimizes the sum described above. If there are multiple optimal sequences, you can output any of them.
Examples
Input
5
1 1 1 1 1
Output
1 1 1 1 1
Input
5
1 6 4 2 8
Output
1 5 3 1 8
Submitted Solution:
```
import sys
readline = sys.stdin.readline
def gcd(a, b):
while b:
a, b = b, a%b
return a
def prsh(N):
prime = [2]
for L in range(3,N):
for p in prime:
if not L % p:
break
if p > L**(1/2):
prime.append(L)
break
return prime
limit = 59
prime = prsh(limit+1)
C = set([tuple()])
Cp = []
for i in range(2, limit+1):
if i >= 30 and i in prime:
Cp.append(i)
continue
for k in C.copy():
if all(gcd(ki, i) == 1 for ki in k):
kn = tuple(list(k) + [i])
C.add(kn)
INF = 10**9+7
N = int(readline())
A = list(map(int, readline().split()))
Ao = A[:]
A.sort()
ans = INF
Ans = None
for ci in C:
for j in range(8):
ci = list(ci) + Cp[:j]
tc = [1]*(N-len(ci)) + ci
res = 0
for a, t in zip(A, tc):
res += abs(a-t)
if ans > res:
ans = res
Ans = tc
buc = [[] for _ in range(limit+1)]
for a, an in zip(A, Ans):
buc[a].append(an)
AA = []
for ao in Ao:
AA.append(buc[ao].pop())
#print(ans)
print(*AA)
```
|
instruction
| 0
| 107,336
| 2
| 214,672
|
No
|
output
| 1
| 107,336
| 2
| 214,673
|
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.