message stringlengths 2 45.8k | message_type stringclasses 2 values | message_id int64 0 1 | conversation_id int64 254 108k | cluster float64 3 3 | __index_level_0__ int64 508 217k |
|---|---|---|---|---|---|
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
[Æsir - CHAOS](https://soundcloud.com/kivawu/aesir-chaos)
[Æsir - V.](https://soundcloud.com/kivawu/aesir-v)
"Everything has been planned out. No more hidden concerns. The condition of Cytus is also perfect.
The time right now...... 00:01:12......
It's time."
The emotion samples are now sufficient. After almost 3 years, it's time for Ivy to awake her bonded sister, Vanessa.
The system inside A.R.C.'s Library core can be considered as an undirected graph with infinite number of processing nodes, numbered with all positive integers (1, 2, 3, …). The node with a number x (x > 1), is directly connected with a node with number (x)/(f(x)), with f(x) being the lowest prime divisor of x.
Vanessa's mind is divided into n fragments. Due to more than 500 years of coma, the fragments have been scattered: the i-th fragment is now located at the node with a number k_i! (a factorial of k_i).
To maximize the chance of successful awakening, Ivy decides to place the samples in a node P, so that the total length of paths from each fragment to P is smallest possible. If there are multiple fragments located at the same node, the path from that node to P needs to be counted multiple times.
In the world of zeros and ones, such a requirement is very simple for Ivy. Not longer than a second later, she has already figured out such a node.
But for a mere human like you, is this still possible?
For simplicity, please answer the minimal sum of paths' lengths from every fragment to the emotion samples' assembly node P.
Input
The first line contains an integer n (1 ≤ n ≤ 10^6) — number of fragments of Vanessa's mind.
The second line contains n integers: k_1, k_2, …, k_n (0 ≤ k_i ≤ 5000), denoting the nodes where fragments of Vanessa's mind are located: the i-th fragment is at the node with a number k_i!.
Output
Print a single integer, denoting the minimal sum of path from every fragment to the node with the emotion samples (a.k.a. node P).
As a reminder, if there are multiple fragments at the same node, the distance from that node to P needs to be counted multiple times as well.
Examples
Input
3
2 1 4
Output
5
Input
4
3 1 4 4
Output
6
Input
4
3 1 4 1
Output
6
Input
5
3 1 4 1 5
Output
11
Note
Considering the first 24 nodes of the system, the node network will look as follows (the nodes 1!, 2!, 3!, 4! are drawn bold):
<image>
For the first example, Ivy will place the emotion samples at the node 1. From here:
* The distance from Vanessa's first fragment to the node 1 is 1.
* The distance from Vanessa's second fragment to the node 1 is 0.
* The distance from Vanessa's third fragment to the node 1 is 4.
The total length is 5.
For the second example, the assembly node will be 6. From here:
* The distance from Vanessa's first fragment to the node 6 is 0.
* The distance from Vanessa's second fragment to the node 6 is 2.
* The distance from Vanessa's third fragment to the node 6 is 2.
* The distance from Vanessa's fourth fragment to the node 6 is again 2.
The total path length is 6.
Submitted Solution:
```
from sys import stdin, stdout
prime = list()
factor = list()
count = list()
dist = list()
N = 0
debugs = False
def find_prime():
global prime
for i in range(2, 5010):
is_prime = True
for j in prime:
if i % j == 0:
is_prime = False
break
if is_prime is True:
prime.append(i)
def calculate_factor(max):
global prime
global factor
global dist
factor = [[0 for x in range(len(prime))] for y in range(5010)]
dist = [0] * (max+1)
d = 0
for i in range(1, max+1):
temp = i
factor[i] = list(factor[i-1])
for j,x in enumerate(prime):
while temp % x == 0:
factor[i][j] +=1
temp = temp / x
d += 1
if temp == 1:
dist[i] = d
break
def dynamic_count():
global count
for i in range (1,len(count)):
count[i] += count[i-1]
def moving(i, left, right, d, current_factor):
global count
global prime
global factor
global N
while (factor[left][i] == factor[right][i]):
d += ((2 * (count[right] - count[left-1])) - N) * (factor[right][i] - current_factor[i])
current_factor[i] = factor[right][i]
i -= 1
if i < 0:
return d
d += ((2 * (count[right] - count[left-1])) - N) * (factor[left][i] - current_factor[i])
current_factor[i] = factor[left][i]
if (debugs is True):
print(prime[i],left,right,count[right] - count[left-1], factor[left][i], current_factor[i])
temp_left = right
while temp_left >= left:
if (factor[temp_left-1][i] != factor[right][i] or temp_left == left ) and count[right] - count[temp_left-1] > int(N/2):
return moving(i, temp_left, right, d, current_factor)
elif factor[temp_left-1][i] != factor[right][i]:
i -= 1
right = temp_left - 1
if i < 0:
return d
temp_left -= 1
return d
def unanem():
global prime
global count
global N
if count[1] > int(N/2):
return 0
current_factor = [0] * 5010
if count[5000] - count[4998] > int(N/2):
return moving(len(prime)-3, 4999, 5000, 0, current_factor)
for i,x in enumerate(prime):
counter = 0
if i == 0:
counter = count[1]
else:
counter = count[prime[i] - 1] - count[prime[i-1] - 1]
if counter>int(N/2):
return moving (i, prime[i-1], prime[i] - 1, 0 , current_factor)
return 0
def main():
global prime
global factor
global count
global N
global debugs
N = int(stdin.readline())
num_list = list(map(int, stdin.readline().split()))
max = 0
for i in num_list:
if max < i:
max = i
if num_list[0] == 2976 and num_list[1] == 2807:
debugs = True
count = [0] * (5010)
for i in num_list:
count[i] += 1
find_prime()
calculate_factor(max)
dynamic_count()
d = unanem()
overall_dist = 0
for i,c in enumerate(count):
if i == max + 1:
break
if i == 0:
continue
overall_dist += (count[i] - count[i-1])*dist[i]
print(overall_dist - d)
main()
``` | instruction | 0 | 74,274 | 3 | 148,548 |
No | output | 1 | 74,274 | 3 | 148,549 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
[Æsir - CHAOS](https://soundcloud.com/kivawu/aesir-chaos)
[Æsir - V.](https://soundcloud.com/kivawu/aesir-v)
"Everything has been planned out. No more hidden concerns. The condition of Cytus is also perfect.
The time right now...... 00:01:12......
It's time."
The emotion samples are now sufficient. After almost 3 years, it's time for Ivy to awake her bonded sister, Vanessa.
The system inside A.R.C.'s Library core can be considered as an undirected graph with infinite number of processing nodes, numbered with all positive integers (1, 2, 3, …). The node with a number x (x > 1), is directly connected with a node with number (x)/(f(x)), with f(x) being the lowest prime divisor of x.
Vanessa's mind is divided into n fragments. Due to more than 500 years of coma, the fragments have been scattered: the i-th fragment is now located at the node with a number k_i! (a factorial of k_i).
To maximize the chance of successful awakening, Ivy decides to place the samples in a node P, so that the total length of paths from each fragment to P is smallest possible. If there are multiple fragments located at the same node, the path from that node to P needs to be counted multiple times.
In the world of zeros and ones, such a requirement is very simple for Ivy. Not longer than a second later, she has already figured out such a node.
But for a mere human like you, is this still possible?
For simplicity, please answer the minimal sum of paths' lengths from every fragment to the emotion samples' assembly node P.
Input
The first line contains an integer n (1 ≤ n ≤ 10^6) — number of fragments of Vanessa's mind.
The second line contains n integers: k_1, k_2, …, k_n (0 ≤ k_i ≤ 5000), denoting the nodes where fragments of Vanessa's mind are located: the i-th fragment is at the node with a number k_i!.
Output
Print a single integer, denoting the minimal sum of path from every fragment to the node with the emotion samples (a.k.a. node P).
As a reminder, if there are multiple fragments at the same node, the distance from that node to P needs to be counted multiple times as well.
Examples
Input
3
2 1 4
Output
5
Input
4
3 1 4 4
Output
6
Input
4
3 1 4 1
Output
6
Input
5
3 1 4 1 5
Output
11
Note
Considering the first 24 nodes of the system, the node network will look as follows (the nodes 1!, 2!, 3!, 4! are drawn bold):
<image>
For the first example, Ivy will place the emotion samples at the node 1. From here:
* The distance from Vanessa's first fragment to the node 1 is 1.
* The distance from Vanessa's second fragment to the node 1 is 0.
* The distance from Vanessa's third fragment to the node 1 is 4.
The total length is 5.
For the second example, the assembly node will be 6. From here:
* The distance from Vanessa's first fragment to the node 6 is 0.
* The distance from Vanessa's second fragment to the node 6 is 2.
* The distance from Vanessa's third fragment to the node 6 is 2.
* The distance from Vanessa's fourth fragment to the node 6 is again 2.
The total path length is 6.
Submitted Solution:
```
from sys import stdin, stdout
prime = list()
factor = list()
count = list()
dist = list()
N = 0
debugs = False
def find_prime():
global prime
for i in range(2, 5010):
is_prime = True
for j in prime:
if i % j == 0:
is_prime = False
break
if is_prime is True:
prime.append(i)
def calculate_factor(max):
global prime
global factor
global dist
factor = [[0 for x in range(len(prime))] for y in range(5010)]
dist = [0] * (max+1)
d = 0
for i in range(1, max+1):
temp = i
factor[i] = list(factor[i-1])
for j,x in enumerate(prime):
while temp % x == 0:
factor[i][j] +=1
temp = temp / x
d += 1
if temp == 1:
dist[i] = d
break
def dynamic_count():
global count
for i in range (1,len(count)):
count[i] += count[i-1]
def moving(i, left, right, d, current_factor):
global count
global prime
global factor
global N
while (factor[left][i] == factor[right][i]):
d += ((2 * (count[right] - count[left-1])) - N) * (factor[right][i] - current_factor[i])
if (debugs is True and prime[i] <= 5):
print("deb",d,prime[i],left,right,count[right] - count[left-1], factor[left][i], current_factor[i])
current_factor[i] = factor[right][i]
i -= 1
if i < 0:
return d
if (debugs is True):
print(prime[i],left,right,count[right] - count[left-1], factor[left][i], factor[right][i])
d += ((2 * (count[right] - count[left-1])) - N) * (factor[left][i] - current_factor[i])
current_factor[i] = factor[left][i]
temp_left = right
while temp_left >= left:
if (factor[temp_left-1][i] != factor[right][i] or temp_left == left ) and count[right] - count[temp_left-1] > int(N/2):
return moving(i, temp_left, right, d, current_factor)
elif factor[temp_left-1][i] != factor[right][i]:
i -= 1
right = temp_left - 1
if i < 0:
return d
temp_left -= 1
return d
def unanem():
global prime
global count
global N
if count[1] > int(N/2):
return 0
current_factor = [0] * 5010
if count[5000] - count[4998] > int(N/2):
return moving(len(prime)-3, 4999, 5000, 0, current_factor)
for i,x in enumerate(prime):
counter = 0
if i == 0:
counter = count[1]
else:
counter = count[prime[i] - 1] - count[prime[i-1] - 1]
if counter>int(N/2):
return moving (i, prime[i-1], prime[i] - 1, 0 , current_factor)
return 0
def main():
global prime
global factor
global count
global N
global debugs
N = int(stdin.readline())
num_list = list(map(int, stdin.readline().split()))
max = 0
for i in num_list:
if max < i:
max = i
if num_list[0] == 2976 and num_list[1] == 2807:
debugs = True
count = [0] * (5010)
for i in num_list:
count[i] += 1
find_prime()
calculate_factor(max)
dynamic_count()
d = unanem()
overall_dist = 0
for i,c in enumerate(count):
if i == max + 1:
break
if i == 0:
continue
overall_dist += (count[i] - count[i-1])*dist[i]
print(overall_dist - d)
main()
``` | instruction | 0 | 74,275 | 3 | 148,550 |
No | output | 1 | 74,275 | 3 | 148,551 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
A group of tourists is going to kayak and catamaran tour. A rented lorry has arrived to the boat depot to take kayaks and catamarans to the point of departure. It's known that all kayaks are of the same size (and each of them occupies the space of 1 cubic metre), and all catamarans are of the same size, but two times bigger than kayaks (and occupy the space of 2 cubic metres).
Each waterborne vehicle has a particular carrying capacity, and it should be noted that waterborne vehicles that look the same can have different carrying capacities. Knowing the truck body volume and the list of waterborne vehicles in the boat depot (for each one its type and carrying capacity are known), find out such set of vehicles that can be taken in the lorry, and that has the maximum total carrying capacity. The truck body volume of the lorry can be used effectively, that is to say you can always put into the lorry a waterborne vehicle that occupies the space not exceeding the free space left in the truck body.
Input
The first line contains a pair of integer numbers n and v (1 ≤ n ≤ 105; 1 ≤ v ≤ 109), where n is the number of waterborne vehicles in the boat depot, and v is the truck body volume of the lorry in cubic metres. The following n lines contain the information about the waterborne vehicles, that is a pair of numbers ti, pi (1 ≤ ti ≤ 2; 1 ≤ pi ≤ 104), where ti is the vehicle type (1 – a kayak, 2 – a catamaran), and pi is its carrying capacity. The waterborne vehicles are enumerated in order of their appearance in the input file.
Output
In the first line print the maximum possible carrying capacity of the set. In the second line print a string consisting of the numbers of the vehicles that make the optimal set. If the answer is not unique, print any of them.
Examples
Input
3 2
1 2
2 7
1 3
Output
7
2
Submitted Solution:
```
n, v = map(int, input().split())
a = []
b = []
for i in range(n):
t, p = map(int, input().split())
if t == 1:
a.append((i, p))
else:
b.append((i, p))
a = sorted(a, key=lambda x: -x[1])
b = sorted(b, key=lambda x: -x[1])
a_pos = -1
b_pos = -1
capacity = 0
while capacity < v:
next_a = a[a_pos + 1][1] if a_pos + 1 < len(a) and capacity + 1 <= v else -1
next_b = b[b_pos + 1][1] if b_pos + 1 < len(b) and capacity + 2 <= v else -1
if next_a == -1 and next_b == -1:
break
if next_a > next_b / 2:
a_pos += 1
capacity += 1
else:
b_pos += 1
capacity += 2
if capacity < v and a_pos > -1 and b_pos + 1 < len(b):
if a[a_pos][1] < b[b_pos + 1][1]:
a_pos -= 1
b_pos += 1
print(sum([x[1] for x in a[:a_pos + 1]]) + sum([x[1] for x in b[:b_pos + 1]]))
for i in range(a_pos + 1):
print(a[i][0] + 1)
for i in range(b_pos + 1):
print(b[i][0] + 1)
``` | instruction | 0 | 74,517 | 3 | 149,034 |
Yes | output | 1 | 74,517 | 3 | 149,035 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
A group of tourists is going to kayak and catamaran tour. A rented lorry has arrived to the boat depot to take kayaks and catamarans to the point of departure. It's known that all kayaks are of the same size (and each of them occupies the space of 1 cubic metre), and all catamarans are of the same size, but two times bigger than kayaks (and occupy the space of 2 cubic metres).
Each waterborne vehicle has a particular carrying capacity, and it should be noted that waterborne vehicles that look the same can have different carrying capacities. Knowing the truck body volume and the list of waterborne vehicles in the boat depot (for each one its type and carrying capacity are known), find out such set of vehicles that can be taken in the lorry, and that has the maximum total carrying capacity. The truck body volume of the lorry can be used effectively, that is to say you can always put into the lorry a waterborne vehicle that occupies the space not exceeding the free space left in the truck body.
Input
The first line contains a pair of integer numbers n and v (1 ≤ n ≤ 105; 1 ≤ v ≤ 109), where n is the number of waterborne vehicles in the boat depot, and v is the truck body volume of the lorry in cubic metres. The following n lines contain the information about the waterborne vehicles, that is a pair of numbers ti, pi (1 ≤ ti ≤ 2; 1 ≤ pi ≤ 104), where ti is the vehicle type (1 – a kayak, 2 – a catamaran), and pi is its carrying capacity. The waterborne vehicles are enumerated in order of their appearance in the input file.
Output
In the first line print the maximum possible carrying capacity of the set. In the second line print a string consisting of the numbers of the vehicles that make the optimal set. If the answer is not unique, print any of them.
Examples
Input
3 2
1 2
2 7
1 3
Output
7
2
Submitted Solution:
```
n, capacity = map(int, input().split())
kayaks, catamarans = [], []
for i in range(n):
vehicle_type, vehicle_capacity = map(int, input().split())
l = kayaks if vehicle_type == 1 else catamarans
l.append(( vehicle_capacity, i + 1 ))
kayaks.sort(key=lambda item: item[0], reverse=True)
catamarans.sort(key=lambda item: item[0], reverse=True)
# print('kayaks', kayaks, 'catamarans', catamarans)
max_capacity = 0
kayaks_cap = [0]
catamarans_cap = [0]
for i in range(min(capacity, len(kayaks))):
kayaks_cap.append(kayaks_cap[i] + kayaks[i][0])
for i in range(min(capacity // 2, len(catamarans))):
catamarans_cap.append(catamarans_cap[i] + catamarans[i][0])
# print('kayaks caps', kayaks_cap, 'catamarans caps', catamarans_cap)
kayaks_idx = 0
catamarans_idx = 0
for i, k in enumerate(kayaks_cap):
if i > capacity:
break
if (k + catamarans_cap[min((capacity - i) // 2, len(catamarans_cap) - 1)] > max_capacity):
max_capacity = k + catamarans_cap[min((capacity - i) // 2, len(catamarans_cap) - 1)]
kayaks_idx = i
catamarans_idx = min((capacity - i) // 2, len(catamarans_cap) - 1)
print(max_capacity)
for i in range(kayaks_idx):
print(kayaks[i][1], end=' ')
for i in range(catamarans_idx):
print(catamarans[i][1], end=' ')
``` | instruction | 0 | 74,518 | 3 | 149,036 |
Yes | output | 1 | 74,518 | 3 | 149,037 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
A group of tourists is going to kayak and catamaran tour. A rented lorry has arrived to the boat depot to take kayaks and catamarans to the point of departure. It's known that all kayaks are of the same size (and each of them occupies the space of 1 cubic metre), and all catamarans are of the same size, but two times bigger than kayaks (and occupy the space of 2 cubic metres).
Each waterborne vehicle has a particular carrying capacity, and it should be noted that waterborne vehicles that look the same can have different carrying capacities. Knowing the truck body volume and the list of waterborne vehicles in the boat depot (for each one its type and carrying capacity are known), find out such set of vehicles that can be taken in the lorry, and that has the maximum total carrying capacity. The truck body volume of the lorry can be used effectively, that is to say you can always put into the lorry a waterborne vehicle that occupies the space not exceeding the free space left in the truck body.
Input
The first line contains a pair of integer numbers n and v (1 ≤ n ≤ 105; 1 ≤ v ≤ 109), where n is the number of waterborne vehicles in the boat depot, and v is the truck body volume of the lorry in cubic metres. The following n lines contain the information about the waterborne vehicles, that is a pair of numbers ti, pi (1 ≤ ti ≤ 2; 1 ≤ pi ≤ 104), where ti is the vehicle type (1 – a kayak, 2 – a catamaran), and pi is its carrying capacity. The waterborne vehicles are enumerated in order of their appearance in the input file.
Output
In the first line print the maximum possible carrying capacity of the set. In the second line print a string consisting of the numbers of the vehicles that make the optimal set. If the answer is not unique, print any of them.
Examples
Input
3 2
1 2
2 7
1 3
Output
7
2
Submitted Solution:
```
import sys
n, v = map(int, input().split())
kayak = []
catam = []
for i in range(0,n):
nums = list(map(int, sys.stdin.readline().split()))
if nums[0] == 1:
kayak.append((nums[1], i + 1))
else:
catam.append((nums[1], i + 1))
# sorts by [0] elementwise
kayak.sort(key=lambda pair: pair[0])
catam.sort(key=lambda pair: pair[0])
# Greedily take kayaks and catamarans
truck = []
while v > 0:
if v == 1:
if kayak:
truck.append(kayak.pop())
v -= 1
else:
if not kayak and not catam:
v = 0
elif not kayak:
truck.append(catam.pop())
v -= 2
elif not catam:
truck.append(kayak.pop())
v -= 1
else:
if len(kayak) == 1:
if kayak[0][0] > catam[-1][0]:
truck.append(kayak.pop())
v -= 1
else:
truck.append(catam.pop())
v -= 2
else:
if kayak[-1][0]+kayak[-2][0] > catam[-1][0]:
truck.append(kayak.pop())
v -= 1
else:
truck.append(catam.pop())
v -= 2
ans = 0
for i in truck:
ans += i[0]
print(ans)
for i in truck:
sys.stdout.write(str(i[1]) + " ")
``` | instruction | 0 | 74,519 | 3 | 149,038 |
Yes | output | 1 | 74,519 | 3 | 149,039 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
A group of tourists is going to kayak and catamaran tour. A rented lorry has arrived to the boat depot to take kayaks and catamarans to the point of departure. It's known that all kayaks are of the same size (and each of them occupies the space of 1 cubic metre), and all catamarans are of the same size, but two times bigger than kayaks (and occupy the space of 2 cubic metres).
Each waterborne vehicle has a particular carrying capacity, and it should be noted that waterborne vehicles that look the same can have different carrying capacities. Knowing the truck body volume and the list of waterborne vehicles in the boat depot (for each one its type and carrying capacity are known), find out such set of vehicles that can be taken in the lorry, and that has the maximum total carrying capacity. The truck body volume of the lorry can be used effectively, that is to say you can always put into the lorry a waterborne vehicle that occupies the space not exceeding the free space left in the truck body.
Input
The first line contains a pair of integer numbers n and v (1 ≤ n ≤ 105; 1 ≤ v ≤ 109), where n is the number of waterborne vehicles in the boat depot, and v is the truck body volume of the lorry in cubic metres. The following n lines contain the information about the waterborne vehicles, that is a pair of numbers ti, pi (1 ≤ ti ≤ 2; 1 ≤ pi ≤ 104), where ti is the vehicle type (1 – a kayak, 2 – a catamaran), and pi is its carrying capacity. The waterborne vehicles are enumerated in order of their appearance in the input file.
Output
In the first line print the maximum possible carrying capacity of the set. In the second line print a string consisting of the numbers of the vehicles that make the optimal set. If the answer is not unique, print any of them.
Examples
Input
3 2
1 2
2 7
1 3
Output
7
2
Submitted Solution:
```
n, v = map(int, input().split())
k = [[0, ' '], [0, ' ']]
c = [[0, ' ']]
sum = 0
vehicles = []
for i in range(n):
q = input().split()
if q[0] == '1':
k += [[int(q[1]), i+1]]
elif q[0] == '2':
c += [[int(q[1]), i+1]]
k.sort(key=lambda a: a[0])
c.sort(key=lambda a: a[0])
for i in range(n):
if c[-1][0] > k[-1][0] + k[-2][0]:
if v >= 2:
add = c[-1][0]
vehicles.append(c[-1][1])
c.pop()
v -= 2
elif v >= 1:
add = k[-1][0]
vehicles.append(k[-1][1])
k.pop()
v -= 1
elif v >= 1:
add = k[-1][0]
vehicles.append(k[-1][1])
k.pop()
v -= 1
sum += add
if v == 0:
break
print(sum)
for i in vehicles:
print(i, end=' ')
``` | instruction | 0 | 74,520 | 3 | 149,040 |
Yes | output | 1 | 74,520 | 3 | 149,041 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
A group of tourists is going to kayak and catamaran tour. A rented lorry has arrived to the boat depot to take kayaks and catamarans to the point of departure. It's known that all kayaks are of the same size (and each of them occupies the space of 1 cubic metre), and all catamarans are of the same size, but two times bigger than kayaks (and occupy the space of 2 cubic metres).
Each waterborne vehicle has a particular carrying capacity, and it should be noted that waterborne vehicles that look the same can have different carrying capacities. Knowing the truck body volume and the list of waterborne vehicles in the boat depot (for each one its type and carrying capacity are known), find out such set of vehicles that can be taken in the lorry, and that has the maximum total carrying capacity. The truck body volume of the lorry can be used effectively, that is to say you can always put into the lorry a waterborne vehicle that occupies the space not exceeding the free space left in the truck body.
Input
The first line contains a pair of integer numbers n and v (1 ≤ n ≤ 105; 1 ≤ v ≤ 109), where n is the number of waterborne vehicles in the boat depot, and v is the truck body volume of the lorry in cubic metres. The following n lines contain the information about the waterborne vehicles, that is a pair of numbers ti, pi (1 ≤ ti ≤ 2; 1 ≤ pi ≤ 104), where ti is the vehicle type (1 – a kayak, 2 – a catamaran), and pi is its carrying capacity. The waterborne vehicles are enumerated in order of their appearance in the input file.
Output
In the first line print the maximum possible carrying capacity of the set. In the second line print a string consisting of the numbers of the vehicles that make the optimal set. If the answer is not unique, print any of them.
Examples
Input
3 2
1 2
2 7
1 3
Output
7
2
Submitted Solution:
```
import sys
n, v = sys.stdin.readline().strip().split()
n = int(n)
v = int(v)
lines = []
for i in range(0, n):
lines.append(sys.stdin.readline().strip())
vehicles = []
for index, vehicle in enumerate(lines):
typ, capacity = vehicle.split()
typ = int(typ)
capacity = int(capacity)
eff = capacity / typ
vehicles.append([eff, typ, capacity, index])
ori_list = vehicles.copy()
vehicles.sort()
lorry_cap = 0
count = 0
caps = 0
indices = []
rev_vehicles = vehicles[::-1]
while lorry_cap < v and count < len(rev_vehicles):
caps += rev_vehicles[count][2]
lorry_cap += rev_vehicles[count][1]
indices.append(rev_vehicles[count][3])
count += 1
if lorry_cap > v:
caps -= rev_vehicles[count-1][2]
lorry_cap -= rev_vehicles[count-1][1]
indices.pop(-1)
for j in range(count, len(rev_vehicles)):
if rev_vehicles[count][1] == 1:
caps += rev_vehicles[count][2]
lorry_cap += rev_vehicles[count][1]
indices.append(rev_vehicles[count][3])
break
if lorry_cap < v:
for l in range(count-1, len(rev_vehicles)):
for a in indices[::-1]:
if ori_list[a][1] == 1 and ori_list[a][2] < rev_vehicles[l][2]:
caps -= ori_list[a][2]
caps += rev_vehicles[l][2]
indices.remove(a)
indices.append(rev_vehicles[l][3])
break
else:
continue
break
print(caps)
num_veh = ''
for m in indices:
num_veh += str(m+1)
num_veh += ' '
print(num_veh[:-1])
``` | instruction | 0 | 74,521 | 3 | 149,042 |
No | output | 1 | 74,521 | 3 | 149,043 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
A group of tourists is going to kayak and catamaran tour. A rented lorry has arrived to the boat depot to take kayaks and catamarans to the point of departure. It's known that all kayaks are of the same size (and each of them occupies the space of 1 cubic metre), and all catamarans are of the same size, but two times bigger than kayaks (and occupy the space of 2 cubic metres).
Each waterborne vehicle has a particular carrying capacity, and it should be noted that waterborne vehicles that look the same can have different carrying capacities. Knowing the truck body volume and the list of waterborne vehicles in the boat depot (for each one its type and carrying capacity are known), find out such set of vehicles that can be taken in the lorry, and that has the maximum total carrying capacity. The truck body volume of the lorry can be used effectively, that is to say you can always put into the lorry a waterborne vehicle that occupies the space not exceeding the free space left in the truck body.
Input
The first line contains a pair of integer numbers n and v (1 ≤ n ≤ 105; 1 ≤ v ≤ 109), where n is the number of waterborne vehicles in the boat depot, and v is the truck body volume of the lorry in cubic metres. The following n lines contain the information about the waterborne vehicles, that is a pair of numbers ti, pi (1 ≤ ti ≤ 2; 1 ≤ pi ≤ 104), where ti is the vehicle type (1 – a kayak, 2 – a catamaran), and pi is its carrying capacity. The waterborne vehicles are enumerated in order of their appearance in the input file.
Output
In the first line print the maximum possible carrying capacity of the set. In the second line print a string consisting of the numbers of the vehicles that make the optimal set. If the answer is not unique, print any of them.
Examples
Input
3 2
1 2
2 7
1 3
Output
7
2
Submitted Solution:
```
stdin = lambda type_ = "int", sep = " ": list(map(eval(type_), input().split(sep)))
n, v = stdin()
vehicles = sorted(((stdin(), i) for i in range(n)), key=lambda x: x[0][1], reverse=True)
total, size = 0, 0
indices = []
get_vehicle = lambda k: vehicles[k][0]
get_index = lambda k: vehicles[k][1]
get_size = lambda k: k[0]
get_value = lambda k: k[1]
i = 0
while i < n:
# print("size: " + str(size))
vehicle = get_vehicle(i)
if size + get_size(vehicle) <= v:
if size + get_size(vehicle) < v or (size + get_size(vehicle) == v and i + 2 >= n):
size, total = size + get_size(vehicle), total + get_value(vehicle)
indices.append(get_index(i))
# print("First if ran")
else:
# print("second if")
curr_vehicle = get_vehicle(i)
next_vehicle = get_vehicle(i + 1)
fut_vehicle = get_vehicle(i + 2)
if get_size(next_vehicle) + get_size(fut_vehicle) == get_size(curr_vehicle):
if curr_vehicle[1] >= next_vehicle[1] + fut_vehicle[1]:
total += curr_vehicle[1]
indices.append(get_index(i))
else:
total += next_vehicle[1] + fut_vehicle[1]
indices.extend([get_index(i), get_index(i + 1)])
size += curr_vehicle[0]
else:
size, total = size + get_size(vehicle), total + get_value(vehicle)
indices.append(get_index(i))
i += 1
print(total)
for i in indices:
print(i + 1)
``` | instruction | 0 | 74,522 | 3 | 149,044 |
No | output | 1 | 74,522 | 3 | 149,045 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
A group of tourists is going to kayak and catamaran tour. A rented lorry has arrived to the boat depot to take kayaks and catamarans to the point of departure. It's known that all kayaks are of the same size (and each of them occupies the space of 1 cubic metre), and all catamarans are of the same size, but two times bigger than kayaks (and occupy the space of 2 cubic metres).
Each waterborne vehicle has a particular carrying capacity, and it should be noted that waterborne vehicles that look the same can have different carrying capacities. Knowing the truck body volume and the list of waterborne vehicles in the boat depot (for each one its type and carrying capacity are known), find out such set of vehicles that can be taken in the lorry, and that has the maximum total carrying capacity. The truck body volume of the lorry can be used effectively, that is to say you can always put into the lorry a waterborne vehicle that occupies the space not exceeding the free space left in the truck body.
Input
The first line contains a pair of integer numbers n and v (1 ≤ n ≤ 105; 1 ≤ v ≤ 109), where n is the number of waterborne vehicles in the boat depot, and v is the truck body volume of the lorry in cubic metres. The following n lines contain the information about the waterborne vehicles, that is a pair of numbers ti, pi (1 ≤ ti ≤ 2; 1 ≤ pi ≤ 104), where ti is the vehicle type (1 – a kayak, 2 – a catamaran), and pi is its carrying capacity. The waterborne vehicles are enumerated in order of their appearance in the input file.
Output
In the first line print the maximum possible carrying capacity of the set. In the second line print a string consisting of the numbers of the vehicles that make the optimal set. If the answer is not unique, print any of them.
Examples
Input
3 2
1 2
2 7
1 3
Output
7
2
Submitted Solution:
```
n_boats, truck_volume = [int(x) for x in input().split()]
kayaks, catamarans = [], []
for i in range(n_boats):
boat_size, boat_capacity = [int(x) for x in input().split()]
if boat_size == 1:
kayaks.append((i+1, boat_capacity))
elif boat_size == 2:
catamarans.append((i+1, boat_capacity))
else:
raise Exception('Unknown boat')
kayaks.sort(reverse=True, key=lambda x: x[1])
catamarans.sort(reverse=True, key=lambda x: x[1])
used_capacity = 0
max_passengers = 0
ids = []
while used_capacity + 2 <= truck_volume and len(kayaks) and len(catamarans):
vehicles = []
if kayaks[0][1] >= catamarans[0][1]:
vehicles.append(kayaks.pop(0))
used_capacity += 1
elif len(kayaks) >= 2 and kayaks[0][1] + kayaks[1][1] >= catamarans[0][1]:
vehicles.append(kayaks.pop(0))
vehicles.append(kayaks.pop(0))
used_capacity += 2
else:
vehicles.append(catamarans.pop(0))
used_capacity += 2
for v in vehicles:
ids.append(v[0])
max_passengers += v[1]
while used_capacity + 2 <= truck_volume and len(catamarans):
vehicle = catamarans.pop(0)
ids.append(vehicle[0])
used_capacity += 2
max_passengers += v[1]
while used_capacity < truck_volume and len(kayaks):
vehicle = kayaks.pop(0)
ids.append(vehicle[0])
used_capacity += 1
max_passengers += v[1]
print(max_passengers)
print(' '.join([str(x) for x in ids]))
``` | instruction | 0 | 74,523 | 3 | 149,046 |
No | output | 1 | 74,523 | 3 | 149,047 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
A group of tourists is going to kayak and catamaran tour. A rented lorry has arrived to the boat depot to take kayaks and catamarans to the point of departure. It's known that all kayaks are of the same size (and each of them occupies the space of 1 cubic metre), and all catamarans are of the same size, but two times bigger than kayaks (and occupy the space of 2 cubic metres).
Each waterborne vehicle has a particular carrying capacity, and it should be noted that waterborne vehicles that look the same can have different carrying capacities. Knowing the truck body volume and the list of waterborne vehicles in the boat depot (for each one its type and carrying capacity are known), find out such set of vehicles that can be taken in the lorry, and that has the maximum total carrying capacity. The truck body volume of the lorry can be used effectively, that is to say you can always put into the lorry a waterborne vehicle that occupies the space not exceeding the free space left in the truck body.
Input
The first line contains a pair of integer numbers n and v (1 ≤ n ≤ 105; 1 ≤ v ≤ 109), where n is the number of waterborne vehicles in the boat depot, and v is the truck body volume of the lorry in cubic metres. The following n lines contain the information about the waterborne vehicles, that is a pair of numbers ti, pi (1 ≤ ti ≤ 2; 1 ≤ pi ≤ 104), where ti is the vehicle type (1 – a kayak, 2 – a catamaran), and pi is its carrying capacity. The waterborne vehicles are enumerated in order of their appearance in the input file.
Output
In the first line print the maximum possible carrying capacity of the set. In the second line print a string consisting of the numbers of the vehicles that make the optimal set. If the answer is not unique, print any of them.
Examples
Input
3 2
1 2
2 7
1 3
Output
7
2
Submitted Solution:
```
from operator import itemgetter
if __name__ == "__main__":
n, v = map(int, input().split(" "))
vehicles = {1:[], 2:[]}
for i in range(n):
vtype, vcarry = map(int, input().split(" "))
vehicles[vtype].append((str(i+1), vcarry))
vehicles[1] = sorted(vehicles[1], key = itemgetter(1), reverse = True)
vehicles[2] = sorted(vehicles[2], key = itemgetter(1), reverse = True)
i1, i2 = 0, 0
s1, s2 = len(vehicles[1]), len(vehicles[2])
ans_max = 0
ans_str = ""
while v != 0 and (i1 != s1 or i2 != s2):
if v == 1 or i2 == s2:
if i1 != s1:
ans_max += vehicles[1][i1][1]
ans_str += vehicles[1][i1][0]
v -= 1
i1 += 1
continue
if i1 == s1:
ans_max += vehicles[2][i2][1]
ans_str += vehicles[2][i2][0]
v -= 2
i2 += 1
continue
if vehicles[1][i1][1] >= vehicles[2][i2][1] or (i1 != s1 - 1 and vehicles[1][i1][1] + vehicles[1][i1+1][1] >= vehicles[2][i2][1]):
ans_max += vehicles[1][i1][1]
ans_str += vehicles[1][i1][0]
v -= 1
i1 += 1
else:
ans_max += vehicles[2][i2][1]
ans_str += vehicles[2][i2][0]
v -= 2
i2 += 1
print(ans_max)
print(ans_str)
``` | instruction | 0 | 74,524 | 3 | 149,048 |
No | output | 1 | 74,524 | 3 | 149,049 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
A remote island chain contains n islands, labeled 1 through n. Bidirectional bridges connect the islands to form a simple cycle — a bridge connects islands 1 and 2, islands 2 and 3, and so on, and additionally a bridge connects islands n and 1. The center of each island contains an identical pedestal, and all but one of the islands has a fragile, uniquely colored statue currently held on the pedestal. The remaining island holds only an empty pedestal.
The islanders want to rearrange the statues in a new order. To do this, they repeat the following process: First, they choose an island directly adjacent to the island containing an empty pedestal. Then, they painstakingly carry the statue on this island across the adjoining bridge and place it on the empty pedestal.
Determine if it is possible for the islanders to arrange the statues in the desired order.
Input
The first line contains a single integer n (2 ≤ n ≤ 200 000) — the total number of islands.
The second line contains n space-separated integers ai (0 ≤ ai ≤ n - 1) — the statue currently placed on the i-th island. If ai = 0, then the island has no statue. It is guaranteed that the ai are distinct.
The third line contains n space-separated integers bi (0 ≤ bi ≤ n - 1) — the desired statues of the ith island. Once again, bi = 0 indicates the island desires no statue. It is guaranteed that the bi are distinct.
Output
Print "YES" (without quotes) if the rearrangement can be done in the existing network, and "NO" otherwise.
Examples
Input
3
1 0 2
2 0 1
Output
YES
Input
2
1 0
0 1
Output
YES
Input
4
1 2 3 0
0 3 2 1
Output
NO
Note
In the first sample, the islanders can first move statue 1 from island 1 to island 2, then move statue 2 from island 3 to island 1, and finally move statue 1 from island 2 to island 3.
In the second sample, the islanders can simply move statue 1 from island 1 to island 2.
In the third sample, no sequence of movements results in the desired position.
Submitted Solution:
```
import io
import sys
import time
import random
#~ start = time.clock()
#~ test = '''3
#~ 1 0 2
#~ 2 0 1'''
#~ test = '''2
#~ 1 0
#~ 0 1'''
#~ test = '''4
#~ 1 2 3 0
#~ 0 3 2 1'''
#~ sys.stdin = io.StringIO(test)
n = int(input())
a = list(map(int, input().split()))
b = list(map(int, input().split()))
def normalize(a):
'''Get rid of zero, move around elements to make element 1 the first'''
zeropos = a.index(0)
del a[zeropos]
ret = a[:]
n = len(a)
count = 0
zeropos = a.index(1)
for i in range(zeropos,n):
ret[count] = a[i]
count += 1
for i in range(0,zeropos):
ret[count+i] = a[i]
return ret
#~ print(normalize(a))
#~ print(normalize(b))
print( "YES" if normalize(a)==normalize(b) else "NO" )
#~ dur = time.clock()-start
#~ print("Time:",dur)
``` | instruction | 0 | 74,598 | 3 | 149,196 |
Yes | output | 1 | 74,598 | 3 | 149,197 |
Provide tags and a correct Python 3 solution for this coding contest problem.
A new dog show on TV is starting next week. On the show dogs are required to demonstrate bottomless stomach, strategic thinking and self-preservation instinct. You and your dog are invited to compete with other participants and naturally you want to win!
On the show a dog needs to eat as many bowls of dog food as possible (bottomless stomach helps here). Dogs compete separately of each other and the rules are as follows:
At the start of the show the dog and the bowls are located on a line. The dog starts at position x = 0 and n bowls are located at positions x = 1, x = 2, ..., x = n. The bowls are numbered from 1 to n from left to right. After the show starts the dog immediately begins to run to the right to the first bowl.
The food inside bowls is not ready for eating at the start because it is too hot (dog's self-preservation instinct prevents eating). More formally, the dog can eat from the i-th bowl after ti seconds from the start of the show or later.
It takes dog 1 second to move from the position x to the position x + 1. The dog is not allowed to move to the left, the dog runs only to the right with the constant speed 1 distance unit per second. When the dog reaches a bowl (say, the bowl i), the following cases are possible:
* the food had cooled down (i.e. it passed at least ti seconds from the show start): the dog immediately eats the food and runs to the right without any stop,
* the food is hot (i.e. it passed less than ti seconds from the show start): the dog has two options: to wait for the i-th bowl, eat the food and continue to run at the moment ti or to skip the i-th bowl and continue to run to the right without any stop.
After T seconds from the start the show ends. If the dog reaches a bowl of food at moment T the dog can not eat it. The show stops before T seconds if the dog had run to the right of the last bowl.
You need to help your dog create a strategy with which the maximum possible number of bowls of food will be eaten in T seconds.
Input
Two integer numbers are given in the first line - n and T (1 ≤ n ≤ 200 000, 1 ≤ T ≤ 2·109) — the number of bowls of food and the time when the dog is stopped.
On the next line numbers t1, t2, ..., tn (1 ≤ ti ≤ 109) are given, where ti is the moment of time when the i-th bowl of food is ready for eating.
Output
Output a single integer — the maximum number of bowls of food the dog will be able to eat in T seconds.
Examples
Input
3 5
1 5 3
Output
2
Input
1 2
1
Output
1
Input
1 1
1
Output
0
Note
In the first example the dog should skip the second bowl to eat from the two bowls (the first and the third). | instruction | 0 | 74,694 | 3 | 149,388 |
Tags: constructive algorithms, data structures, greedy
Correct Solution:
```
# using the min-heap
from heapq import heappush,heappop
bowels,Time = map(int,input().split())
myLine = [-int(b) for b in input().split()]
gulp = []; eat = 0
for i in range(1,min(bowels+1,Time)):
# redundant (now that i look at it. the min does that already)
if i >= Time:
break
while gulp and -gulp[0] >= Time - i:
# remove the bowel with the highest time penalty
heappop(gulp)
# Check if the option is viable
if -myLine[i-1] < Time:
# Remove the step penalty and store the remaining
heappush(gulp,myLine[i-1] + i)
eat = max(len(gulp),eat)
print (eat)
``` | output | 1 | 74,694 | 3 | 149,389 |
Provide tags and a correct Python 3 solution for this coding contest problem.
A new dog show on TV is starting next week. On the show dogs are required to demonstrate bottomless stomach, strategic thinking and self-preservation instinct. You and your dog are invited to compete with other participants and naturally you want to win!
On the show a dog needs to eat as many bowls of dog food as possible (bottomless stomach helps here). Dogs compete separately of each other and the rules are as follows:
At the start of the show the dog and the bowls are located on a line. The dog starts at position x = 0 and n bowls are located at positions x = 1, x = 2, ..., x = n. The bowls are numbered from 1 to n from left to right. After the show starts the dog immediately begins to run to the right to the first bowl.
The food inside bowls is not ready for eating at the start because it is too hot (dog's self-preservation instinct prevents eating). More formally, the dog can eat from the i-th bowl after ti seconds from the start of the show or later.
It takes dog 1 second to move from the position x to the position x + 1. The dog is not allowed to move to the left, the dog runs only to the right with the constant speed 1 distance unit per second. When the dog reaches a bowl (say, the bowl i), the following cases are possible:
* the food had cooled down (i.e. it passed at least ti seconds from the show start): the dog immediately eats the food and runs to the right without any stop,
* the food is hot (i.e. it passed less than ti seconds from the show start): the dog has two options: to wait for the i-th bowl, eat the food and continue to run at the moment ti or to skip the i-th bowl and continue to run to the right without any stop.
After T seconds from the start the show ends. If the dog reaches a bowl of food at moment T the dog can not eat it. The show stops before T seconds if the dog had run to the right of the last bowl.
You need to help your dog create a strategy with which the maximum possible number of bowls of food will be eaten in T seconds.
Input
Two integer numbers are given in the first line - n and T (1 ≤ n ≤ 200 000, 1 ≤ T ≤ 2·109) — the number of bowls of food and the time when the dog is stopped.
On the next line numbers t1, t2, ..., tn (1 ≤ ti ≤ 109) are given, where ti is the moment of time when the i-th bowl of food is ready for eating.
Output
Output a single integer — the maximum number of bowls of food the dog will be able to eat in T seconds.
Examples
Input
3 5
1 5 3
Output
2
Input
1 2
1
Output
1
Input
1 1
1
Output
0
Note
In the first example the dog should skip the second bowl to eat from the two bowls (the first and the third). | instruction | 0 | 74,695 | 3 | 149,390 |
Tags: constructive algorithms, data structures, greedy
Correct Solution:
```
from heapq import heappush, heappop
n, m = [int(i) for i in input().split()]
food = 0
tummy = []
dish = [ -int(i) for i in input().split()]
for i in range(1, min(m, n+1)):
while tummy and -tummy[0] >= m- i:
heappop(tummy)
if max(-dish[i-1], i) < m:
heappush(tummy, dish[i-1] + i)
food = max(len(tummy), food)
print(food)
``` | output | 1 | 74,695 | 3 | 149,391 |
Provide tags and a correct Python 3 solution for this coding contest problem.
A new dog show on TV is starting next week. On the show dogs are required to demonstrate bottomless stomach, strategic thinking and self-preservation instinct. You and your dog are invited to compete with other participants and naturally you want to win!
On the show a dog needs to eat as many bowls of dog food as possible (bottomless stomach helps here). Dogs compete separately of each other and the rules are as follows:
At the start of the show the dog and the bowls are located on a line. The dog starts at position x = 0 and n bowls are located at positions x = 1, x = 2, ..., x = n. The bowls are numbered from 1 to n from left to right. After the show starts the dog immediately begins to run to the right to the first bowl.
The food inside bowls is not ready for eating at the start because it is too hot (dog's self-preservation instinct prevents eating). More formally, the dog can eat from the i-th bowl after ti seconds from the start of the show or later.
It takes dog 1 second to move from the position x to the position x + 1. The dog is not allowed to move to the left, the dog runs only to the right with the constant speed 1 distance unit per second. When the dog reaches a bowl (say, the bowl i), the following cases are possible:
* the food had cooled down (i.e. it passed at least ti seconds from the show start): the dog immediately eats the food and runs to the right without any stop,
* the food is hot (i.e. it passed less than ti seconds from the show start): the dog has two options: to wait for the i-th bowl, eat the food and continue to run at the moment ti or to skip the i-th bowl and continue to run to the right without any stop.
After T seconds from the start the show ends. If the dog reaches a bowl of food at moment T the dog can not eat it. The show stops before T seconds if the dog had run to the right of the last bowl.
You need to help your dog create a strategy with which the maximum possible number of bowls of food will be eaten in T seconds.
Input
Two integer numbers are given in the first line - n and T (1 ≤ n ≤ 200 000, 1 ≤ T ≤ 2·109) — the number of bowls of food and the time when the dog is stopped.
On the next line numbers t1, t2, ..., tn (1 ≤ ti ≤ 109) are given, where ti is the moment of time when the i-th bowl of food is ready for eating.
Output
Output a single integer — the maximum number of bowls of food the dog will be able to eat in T seconds.
Examples
Input
3 5
1 5 3
Output
2
Input
1 2
1
Output
1
Input
1 1
1
Output
0
Note
In the first example the dog should skip the second bowl to eat from the two bowls (the first and the third). | instruction | 0 | 74,696 | 3 | 149,392 |
Tags: constructive algorithms, data structures, greedy
Correct Solution:
```
n, T = map(int, input().split())
ts = list(map(int, input().split()))
intervals = []
for i in range(n):
start = max(0, ts[i] - i - 1)
end = T - i - 2
if start > end:
continue
intervals.append((start, -1))
intervals.append((end, 1))
intervals.sort()
ans = 0
current = 0
for _, val in intervals:
current -= val
ans = max(ans, current)
print(ans)
``` | output | 1 | 74,696 | 3 | 149,393 |
Provide tags and a correct Python 3 solution for this coding contest problem.
A new dog show on TV is starting next week. On the show dogs are required to demonstrate bottomless stomach, strategic thinking and self-preservation instinct. You and your dog are invited to compete with other participants and naturally you want to win!
On the show a dog needs to eat as many bowls of dog food as possible (bottomless stomach helps here). Dogs compete separately of each other and the rules are as follows:
At the start of the show the dog and the bowls are located on a line. The dog starts at position x = 0 and n bowls are located at positions x = 1, x = 2, ..., x = n. The bowls are numbered from 1 to n from left to right. After the show starts the dog immediately begins to run to the right to the first bowl.
The food inside bowls is not ready for eating at the start because it is too hot (dog's self-preservation instinct prevents eating). More formally, the dog can eat from the i-th bowl after ti seconds from the start of the show or later.
It takes dog 1 second to move from the position x to the position x + 1. The dog is not allowed to move to the left, the dog runs only to the right with the constant speed 1 distance unit per second. When the dog reaches a bowl (say, the bowl i), the following cases are possible:
* the food had cooled down (i.e. it passed at least ti seconds from the show start): the dog immediately eats the food and runs to the right without any stop,
* the food is hot (i.e. it passed less than ti seconds from the show start): the dog has two options: to wait for the i-th bowl, eat the food and continue to run at the moment ti or to skip the i-th bowl and continue to run to the right without any stop.
After T seconds from the start the show ends. If the dog reaches a bowl of food at moment T the dog can not eat it. The show stops before T seconds if the dog had run to the right of the last bowl.
You need to help your dog create a strategy with which the maximum possible number of bowls of food will be eaten in T seconds.
Input
Two integer numbers are given in the first line - n and T (1 ≤ n ≤ 200 000, 1 ≤ T ≤ 2·109) — the number of bowls of food and the time when the dog is stopped.
On the next line numbers t1, t2, ..., tn (1 ≤ ti ≤ 109) are given, where ti is the moment of time when the i-th bowl of food is ready for eating.
Output
Output a single integer — the maximum number of bowls of food the dog will be able to eat in T seconds.
Examples
Input
3 5
1 5 3
Output
2
Input
1 2
1
Output
1
Input
1 1
1
Output
0
Note
In the first example the dog should skip the second bowl to eat from the two bowls (the first and the third). | instruction | 0 | 74,697 | 3 | 149,394 |
Tags: constructive algorithms, data structures, greedy
Correct Solution:
```
# using the min-heap
from heapq import heappush,heappop
bowels,Time = map(int,input().split())
myLine = [-int(b) for b in input().split()]
gulp = []; eat = 0
for i in range(1,min(bowels+1,Time)):
while gulp and -gulp[0] >= Time - i:
# remove the bowel with the highest time penalty
heappop(gulp)
# Check if the option is viable
if -myLine[i-1] < Time:
# Remove the step penalty and store the remaining
heappush(gulp,myLine[i-1] + i)
eat = max(len(gulp),eat)
print (eat)
``` | output | 1 | 74,697 | 3 | 149,395 |
Provide tags and a correct Python 3 solution for this coding contest problem.
A new dog show on TV is starting next week. On the show dogs are required to demonstrate bottomless stomach, strategic thinking and self-preservation instinct. You and your dog are invited to compete with other participants and naturally you want to win!
On the show a dog needs to eat as many bowls of dog food as possible (bottomless stomach helps here). Dogs compete separately of each other and the rules are as follows:
At the start of the show the dog and the bowls are located on a line. The dog starts at position x = 0 and n bowls are located at positions x = 1, x = 2, ..., x = n. The bowls are numbered from 1 to n from left to right. After the show starts the dog immediately begins to run to the right to the first bowl.
The food inside bowls is not ready for eating at the start because it is too hot (dog's self-preservation instinct prevents eating). More formally, the dog can eat from the i-th bowl after ti seconds from the start of the show or later.
It takes dog 1 second to move from the position x to the position x + 1. The dog is not allowed to move to the left, the dog runs only to the right with the constant speed 1 distance unit per second. When the dog reaches a bowl (say, the bowl i), the following cases are possible:
* the food had cooled down (i.e. it passed at least ti seconds from the show start): the dog immediately eats the food and runs to the right without any stop,
* the food is hot (i.e. it passed less than ti seconds from the show start): the dog has two options: to wait for the i-th bowl, eat the food and continue to run at the moment ti or to skip the i-th bowl and continue to run to the right without any stop.
After T seconds from the start the show ends. If the dog reaches a bowl of food at moment T the dog can not eat it. The show stops before T seconds if the dog had run to the right of the last bowl.
You need to help your dog create a strategy with which the maximum possible number of bowls of food will be eaten in T seconds.
Input
Two integer numbers are given in the first line - n and T (1 ≤ n ≤ 200 000, 1 ≤ T ≤ 2·109) — the number of bowls of food and the time when the dog is stopped.
On the next line numbers t1, t2, ..., tn (1 ≤ ti ≤ 109) are given, where ti is the moment of time when the i-th bowl of food is ready for eating.
Output
Output a single integer — the maximum number of bowls of food the dog will be able to eat in T seconds.
Examples
Input
3 5
1 5 3
Output
2
Input
1 2
1
Output
1
Input
1 1
1
Output
0
Note
In the first example the dog should skip the second bowl to eat from the two bowls (the first and the third). | instruction | 0 | 74,698 | 3 | 149,396 |
Tags: constructive algorithms, data structures, greedy
Correct Solution:
```
# using the min-heap
from heapq import heappush,heappop
bowels,Time = map(int,input().split())
myLine = [-int(b) for b in input().split()]
gulp = []; eat = 0
for i in range(1,min(bowels+1,Time)):
# Terminate in cases where bowels > Time
if i >= Time:
break
while gulp and -gulp[0] >= Time - i:
# remove the bowel with the highest time penalty
heappop(gulp)
# Check if the option is viable
if -myLine[i-1] < Time:
# Remove the step penalty and store the remaining
heappush(gulp,myLine[i-1] + i)
eat = max(len(gulp),eat)
print (eat)
``` | output | 1 | 74,698 | 3 | 149,397 |
Provide tags and a correct Python 3 solution for this coding contest problem.
A new dog show on TV is starting next week. On the show dogs are required to demonstrate bottomless stomach, strategic thinking and self-preservation instinct. You and your dog are invited to compete with other participants and naturally you want to win!
On the show a dog needs to eat as many bowls of dog food as possible (bottomless stomach helps here). Dogs compete separately of each other and the rules are as follows:
At the start of the show the dog and the bowls are located on a line. The dog starts at position x = 0 and n bowls are located at positions x = 1, x = 2, ..., x = n. The bowls are numbered from 1 to n from left to right. After the show starts the dog immediately begins to run to the right to the first bowl.
The food inside bowls is not ready for eating at the start because it is too hot (dog's self-preservation instinct prevents eating). More formally, the dog can eat from the i-th bowl after ti seconds from the start of the show or later.
It takes dog 1 second to move from the position x to the position x + 1. The dog is not allowed to move to the left, the dog runs only to the right with the constant speed 1 distance unit per second. When the dog reaches a bowl (say, the bowl i), the following cases are possible:
* the food had cooled down (i.e. it passed at least ti seconds from the show start): the dog immediately eats the food and runs to the right without any stop,
* the food is hot (i.e. it passed less than ti seconds from the show start): the dog has two options: to wait for the i-th bowl, eat the food and continue to run at the moment ti or to skip the i-th bowl and continue to run to the right without any stop.
After T seconds from the start the show ends. If the dog reaches a bowl of food at moment T the dog can not eat it. The show stops before T seconds if the dog had run to the right of the last bowl.
You need to help your dog create a strategy with which the maximum possible number of bowls of food will be eaten in T seconds.
Input
Two integer numbers are given in the first line - n and T (1 ≤ n ≤ 200 000, 1 ≤ T ≤ 2·109) — the number of bowls of food and the time when the dog is stopped.
On the next line numbers t1, t2, ..., tn (1 ≤ ti ≤ 109) are given, where ti is the moment of time when the i-th bowl of food is ready for eating.
Output
Output a single integer — the maximum number of bowls of food the dog will be able to eat in T seconds.
Examples
Input
3 5
1 5 3
Output
2
Input
1 2
1
Output
1
Input
1 1
1
Output
0
Note
In the first example the dog should skip the second bowl to eat from the two bowls (the first and the third). | instruction | 0 | 74,699 | 3 | 149,398 |
Tags: constructive algorithms, data structures, greedy
Correct Solution:
```
n, t = map(int,input().split())
wait = list(map(int,input().split()))
seg = []
for i in range(n):
# to get the food in wait[i], wait __ seconds before running
m = max(0, wait[i]-i-1)
M = t-i-2
if m > M: continue
seg.append((m, -1))
seg.append((M, 1))
seg.sort()
ans = 0
cur = 0
for t, q in seg:
cur-= q
ans = max(ans, cur)
print(ans)
``` | output | 1 | 74,699 | 3 | 149,399 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
A new dog show on TV is starting next week. On the show dogs are required to demonstrate bottomless stomach, strategic thinking and self-preservation instinct. You and your dog are invited to compete with other participants and naturally you want to win!
On the show a dog needs to eat as many bowls of dog food as possible (bottomless stomach helps here). Dogs compete separately of each other and the rules are as follows:
At the start of the show the dog and the bowls are located on a line. The dog starts at position x = 0 and n bowls are located at positions x = 1, x = 2, ..., x = n. The bowls are numbered from 1 to n from left to right. After the show starts the dog immediately begins to run to the right to the first bowl.
The food inside bowls is not ready for eating at the start because it is too hot (dog's self-preservation instinct prevents eating). More formally, the dog can eat from the i-th bowl after ti seconds from the start of the show or later.
It takes dog 1 second to move from the position x to the position x + 1. The dog is not allowed to move to the left, the dog runs only to the right with the constant speed 1 distance unit per second. When the dog reaches a bowl (say, the bowl i), the following cases are possible:
* the food had cooled down (i.e. it passed at least ti seconds from the show start): the dog immediately eats the food and runs to the right without any stop,
* the food is hot (i.e. it passed less than ti seconds from the show start): the dog has two options: to wait for the i-th bowl, eat the food and continue to run at the moment ti or to skip the i-th bowl and continue to run to the right without any stop.
After T seconds from the start the show ends. If the dog reaches a bowl of food at moment T the dog can not eat it. The show stops before T seconds if the dog had run to the right of the last bowl.
You need to help your dog create a strategy with which the maximum possible number of bowls of food will be eaten in T seconds.
Input
Two integer numbers are given in the first line - n and T (1 ≤ n ≤ 200 000, 1 ≤ T ≤ 2·109) — the number of bowls of food and the time when the dog is stopped.
On the next line numbers t1, t2, ..., tn (1 ≤ ti ≤ 109) are given, where ti is the moment of time when the i-th bowl of food is ready for eating.
Output
Output a single integer — the maximum number of bowls of food the dog will be able to eat in T seconds.
Examples
Input
3 5
1 5 3
Output
2
Input
1 2
1
Output
1
Input
1 1
1
Output
0
Note
In the first example the dog should skip the second bowl to eat from the two bowls (the first and the third).
Submitted Solution:
```
n, T = input().strip().split(' ')
n,T = int(n), int(T)
a = input().strip().split(' ')
a = [int(i) for i in a]
eat = 0
time = 1
for i in range(len(a)):
if time == T:
break
while a[i] != 0:
for k in range(len(a)):
if a[k] != 0:
a[k]-=1
time +=1
if time == T:
break
if a[i] == 0:
eat += 1
time +=1
print(eat)
``` | instruction | 0 | 74,700 | 3 | 149,400 |
No | output | 1 | 74,700 | 3 | 149,401 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
A new dog show on TV is starting next week. On the show dogs are required to demonstrate bottomless stomach, strategic thinking and self-preservation instinct. You and your dog are invited to compete with other participants and naturally you want to win!
On the show a dog needs to eat as many bowls of dog food as possible (bottomless stomach helps here). Dogs compete separately of each other and the rules are as follows:
At the start of the show the dog and the bowls are located on a line. The dog starts at position x = 0 and n bowls are located at positions x = 1, x = 2, ..., x = n. The bowls are numbered from 1 to n from left to right. After the show starts the dog immediately begins to run to the right to the first bowl.
The food inside bowls is not ready for eating at the start because it is too hot (dog's self-preservation instinct prevents eating). More formally, the dog can eat from the i-th bowl after ti seconds from the start of the show or later.
It takes dog 1 second to move from the position x to the position x + 1. The dog is not allowed to move to the left, the dog runs only to the right with the constant speed 1 distance unit per second. When the dog reaches a bowl (say, the bowl i), the following cases are possible:
* the food had cooled down (i.e. it passed at least ti seconds from the show start): the dog immediately eats the food and runs to the right without any stop,
* the food is hot (i.e. it passed less than ti seconds from the show start): the dog has two options: to wait for the i-th bowl, eat the food and continue to run at the moment ti or to skip the i-th bowl and continue to run to the right without any stop.
After T seconds from the start the show ends. If the dog reaches a bowl of food at moment T the dog can not eat it. The show stops before T seconds if the dog had run to the right of the last bowl.
You need to help your dog create a strategy with which the maximum possible number of bowls of food will be eaten in T seconds.
Input
Two integer numbers are given in the first line - n and T (1 ≤ n ≤ 200 000, 1 ≤ T ≤ 2·109) — the number of bowls of food and the time when the dog is stopped.
On the next line numbers t1, t2, ..., tn (1 ≤ ti ≤ 109) are given, where ti is the moment of time when the i-th bowl of food is ready for eating.
Output
Output a single integer — the maximum number of bowls of food the dog will be able to eat in T seconds.
Examples
Input
3 5
1 5 3
Output
2
Input
1 2
1
Output
1
Input
1 1
1
Output
0
Note
In the first example the dog should skip the second bowl to eat from the two bowls (the first and the third).
Submitted Solution:
```
from heapq import heappush, heappop
n, m = [int(i) for i in input().split()]
food = 0
tummy = []
dish = [ -int(i) for i in input().split()]
for i in range(1, min(m, n+1)):
while tummy and -tummy[0] >= m- i:
heappop(tummy)
if max(-dish[i-1], i) < m:
heappush(tummy, -(dish[i-1] - i))
food = max(len(tummy), food)
print(food)
``` | instruction | 0 | 74,701 | 3 | 149,402 |
No | output | 1 | 74,701 | 3 | 149,403 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
This is a story in a depopulated area. In this area, houses are sparsely built along a straight road called Country Road. Until now, there was no electricity in this area, but this time the government will give us some generators. You can install the generators wherever you like, but in order for electricity to be supplied to your home, you must be connected to one of the generators via an electric wire, which incurs a cost proportional to its length. As the only technical civil servant in the area, your job is to seek generator and wire placement that minimizes the total length of wires, provided that electricity is supplied to all homes. Is. Since the capacity of the generator is large enough, it is assumed that electricity can be supplied to as many houses as possible.
Figure 2 shows the first data set of the sample input. To give the optimum placement for this problem, place the generators at the positions x = 20 and x = 80 as shown in the figure, and draw the wires at the positions shown in gray in the figure, respectively.
Example of generator and wire placement (first dataset in input example).
---
Figure 2: Example of generator and wire placement (first dataset in input example).
Input
The number of datasets t (0 <t ≤ 50) is given on the first line of the input.
Subsequently, t datasets are given. Each dataset is given in two lines in the following format.
n k
x1 x2 ... xn
n is the number of houses and k is the number of generators. x1, x2, ..., xn are one-dimensional coordinates that represent the position of the house, respectively. All of these values are integers and satisfy 0 <n ≤ 100000, 0 <k ≤ 100000, 0 ≤ x1 <x2 <... <xn ≤ 1000000.
In addition, 90% of the dataset satisfies 0 <n ≤ 100, 0 <k ≤ 100.
Output
For each dataset, output the minimum total required wire length in one line.
Example
Input
6
5 2
10 30 40 70 100
7 3
3 6 10 17 21 26 28
1 1
100
2 1
0 1000000
3 5
30 70 150
6 4
0 10 20 30 40 50
Output
60
13
0
1000000
0
20
Submitted Solution:
```
trial = int(input())
for t in range(trial):
housecnt,elec = (int(n) for n in input().split(" "))
house = [int(n) for n in input().split(" ")]
maxlist = []
for h in range(housecnt-1):
maxlist.append(house[h+1]-house[h])
maxlist.sort()
for p in range(min(housecnt-1,elec-1)):
maxlist.pop()
print(sum(maxlist))
``` | instruction | 0 | 74,904 | 3 | 149,808 |
Yes | output | 1 | 74,904 | 3 | 149,809 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
This is a story in a depopulated area. In this area, houses are sparsely built along a straight road called Country Road. Until now, there was no electricity in this area, but this time the government will give us some generators. You can install the generators wherever you like, but in order for electricity to be supplied to your home, you must be connected to one of the generators via an electric wire, which incurs a cost proportional to its length. As the only technical civil servant in the area, your job is to seek generator and wire placement that minimizes the total length of wires, provided that electricity is supplied to all homes. Is. Since the capacity of the generator is large enough, it is assumed that electricity can be supplied to as many houses as possible.
Figure 2 shows the first data set of the sample input. To give the optimum placement for this problem, place the generators at the positions x = 20 and x = 80 as shown in the figure, and draw the wires at the positions shown in gray in the figure, respectively.
Example of generator and wire placement (first dataset in input example).
---
Figure 2: Example of generator and wire placement (first dataset in input example).
Input
The number of datasets t (0 <t ≤ 50) is given on the first line of the input.
Subsequently, t datasets are given. Each dataset is given in two lines in the following format.
n k
x1 x2 ... xn
n is the number of houses and k is the number of generators. x1, x2, ..., xn are one-dimensional coordinates that represent the position of the house, respectively. All of these values are integers and satisfy 0 <n ≤ 100000, 0 <k ≤ 100000, 0 ≤ x1 <x2 <... <xn ≤ 1000000.
In addition, 90% of the dataset satisfies 0 <n ≤ 100, 0 <k ≤ 100.
Output
For each dataset, output the minimum total required wire length in one line.
Example
Input
6
5 2
10 30 40 70 100
7 3
3 6 10 17 21 26 28
1 1
100
2 1
0 1000000
3 5
30 70 150
6 4
0 10 20 30 40 50
Output
60
13
0
1000000
0
20
Submitted Solution:
```
for t in range(int(input())):
n, k = map(int, input().split())
X = list(map(int, input().split()))
mid = [X[i] - X[i - 1] for i in range(1, n)]
mid.sort()
ans = [0, sum(mid[:n-k])][k<n]
print(ans)
``` | instruction | 0 | 74,905 | 3 | 149,810 |
Yes | output | 1 | 74,905 | 3 | 149,811 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
This is a story in a depopulated area. In this area, houses are sparsely built along a straight road called Country Road. Until now, there was no electricity in this area, but this time the government will give us some generators. You can install the generators wherever you like, but in order for electricity to be supplied to your home, you must be connected to one of the generators via an electric wire, which incurs a cost proportional to its length. As the only technical civil servant in the area, your job is to seek generator and wire placement that minimizes the total length of wires, provided that electricity is supplied to all homes. Is. Since the capacity of the generator is large enough, it is assumed that electricity can be supplied to as many houses as possible.
Figure 2 shows the first data set of the sample input. To give the optimum placement for this problem, place the generators at the positions x = 20 and x = 80 as shown in the figure, and draw the wires at the positions shown in gray in the figure, respectively.
Example of generator and wire placement (first dataset in input example).
---
Figure 2: Example of generator and wire placement (first dataset in input example).
Input
The number of datasets t (0 <t ≤ 50) is given on the first line of the input.
Subsequently, t datasets are given. Each dataset is given in two lines in the following format.
n k
x1 x2 ... xn
n is the number of houses and k is the number of generators. x1, x2, ..., xn are one-dimensional coordinates that represent the position of the house, respectively. All of these values are integers and satisfy 0 <n ≤ 100000, 0 <k ≤ 100000, 0 ≤ x1 <x2 <... <xn ≤ 1000000.
In addition, 90% of the dataset satisfies 0 <n ≤ 100, 0 <k ≤ 100.
Output
For each dataset, output the minimum total required wire length in one line.
Example
Input
6
5 2
10 30 40 70 100
7 3
3 6 10 17 21 26 28
1 1
100
2 1
0 1000000
3 5
30 70 150
6 4
0 10 20 30 40 50
Output
60
13
0
1000000
0
20
Submitted Solution:
```
t = int(input())
ans = [0 for i in range(t)]
for _ in range(t):
n, k = map(int, input().split())
li = list(map(int, input().split()))
if n <= k:
continue
dis = []
for i in range(n-1):
dis.append(li[i+1]-li[i])
dis.sort()
ans[_] = (sum(dis[:n-k]))
for a in ans:
print(a)
``` | instruction | 0 | 74,906 | 3 | 149,812 |
Yes | output | 1 | 74,906 | 3 | 149,813 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
This is a story in a depopulated area. In this area, houses are sparsely built along a straight road called Country Road. Until now, there was no electricity in this area, but this time the government will give us some generators. You can install the generators wherever you like, but in order for electricity to be supplied to your home, you must be connected to one of the generators via an electric wire, which incurs a cost proportional to its length. As the only technical civil servant in the area, your job is to seek generator and wire placement that minimizes the total length of wires, provided that electricity is supplied to all homes. Is. Since the capacity of the generator is large enough, it is assumed that electricity can be supplied to as many houses as possible.
Figure 2 shows the first data set of the sample input. To give the optimum placement for this problem, place the generators at the positions x = 20 and x = 80 as shown in the figure, and draw the wires at the positions shown in gray in the figure, respectively.
Example of generator and wire placement (first dataset in input example).
---
Figure 2: Example of generator and wire placement (first dataset in input example).
Input
The number of datasets t (0 <t ≤ 50) is given on the first line of the input.
Subsequently, t datasets are given. Each dataset is given in two lines in the following format.
n k
x1 x2 ... xn
n is the number of houses and k is the number of generators. x1, x2, ..., xn are one-dimensional coordinates that represent the position of the house, respectively. All of these values are integers and satisfy 0 <n ≤ 100000, 0 <k ≤ 100000, 0 ≤ x1 <x2 <... <xn ≤ 1000000.
In addition, 90% of the dataset satisfies 0 <n ≤ 100, 0 <k ≤ 100.
Output
For each dataset, output the minimum total required wire length in one line.
Example
Input
6
5 2
10 30 40 70 100
7 3
3 6 10 17 21 26 28
1 1
100
2 1
0 1000000
3 5
30 70 150
6 4
0 10 20 30 40 50
Output
60
13
0
1000000
0
20
Submitted Solution:
```
NUM=int(input())
for sect in range(NUM):
n,k=list(map(int,input().strip().split()))
x=list(map(int,input().strip().split()))
x.sort()
diff=[]
for i in range(1,len(x)):
diff.append(x[i]-x[i-1])
diff.sort(reverse=True)
s=sum(diff[:k-1])
print(max(x)-min(x)-s)
``` | instruction | 0 | 74,907 | 3 | 149,814 |
Yes | output | 1 | 74,907 | 3 | 149,815 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
This is a story in a depopulated area. In this area, houses are sparsely built along a straight road called Country Road. Until now, there was no electricity in this area, but this time the government will give us some generators. You can install the generators wherever you like, but in order for electricity to be supplied to your home, you must be connected to one of the generators via an electric wire, which incurs a cost proportional to its length. As the only technical civil servant in the area, your job is to seek generator and wire placement that minimizes the total length of wires, provided that electricity is supplied to all homes. Is. Since the capacity of the generator is large enough, it is assumed that electricity can be supplied to as many houses as possible.
Figure 2 shows the first data set of the sample input. To give the optimum placement for this problem, place the generators at the positions x = 20 and x = 80 as shown in the figure, and draw the wires at the positions shown in gray in the figure, respectively.
Example of generator and wire placement (first dataset in input example).
---
Figure 2: Example of generator and wire placement (first dataset in input example).
Input
The number of datasets t (0 <t ≤ 50) is given on the first line of the input.
Subsequently, t datasets are given. Each dataset is given in two lines in the following format.
n k
x1 x2 ... xn
n is the number of houses and k is the number of generators. x1, x2, ..., xn are one-dimensional coordinates that represent the position of the house, respectively. All of these values are integers and satisfy 0 <n ≤ 100000, 0 <k ≤ 100000, 0 ≤ x1 <x2 <... <xn ≤ 1000000.
In addition, 90% of the dataset satisfies 0 <n ≤ 100, 0 <k ≤ 100.
Output
For each dataset, output the minimum total required wire length in one line.
Example
Input
6
5 2
10 30 40 70 100
7 3
3 6 10 17 21 26 28
1 1
100
2 1
0 1000000
3 5
30 70 150
6 4
0 10 20 30 40 50
Output
60
13
0
1000000
0
20
Submitted Solution:
```
t=int(input())
for j in range(t):
n,k=map(int,input().split())
l=list(map(int,input().split()))
l1=[]
for i in range(n-1):
l1.append(l[i+1]-l[i])
l1=sorted(l1)
for i in range(k-1):
del l1[-1]
s=0
for i in l1:
s+=i
print(s)
``` | instruction | 0 | 74,908 | 3 | 149,816 |
No | output | 1 | 74,908 | 3 | 149,817 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
This is a story in a depopulated area. In this area, houses are sparsely built along a straight road called Country Road. Until now, there was no electricity in this area, but this time the government will give us some generators. You can install the generators wherever you like, but in order for electricity to be supplied to your home, you must be connected to one of the generators via an electric wire, which incurs a cost proportional to its length. As the only technical civil servant in the area, your job is to seek generator and wire placement that minimizes the total length of wires, provided that electricity is supplied to all homes. Is. Since the capacity of the generator is large enough, it is assumed that electricity can be supplied to as many houses as possible.
Figure 2 shows the first data set of the sample input. To give the optimum placement for this problem, place the generators at the positions x = 20 and x = 80 as shown in the figure, and draw the wires at the positions shown in gray in the figure, respectively.
Example of generator and wire placement (first dataset in input example).
---
Figure 2: Example of generator and wire placement (first dataset in input example).
Input
The number of datasets t (0 <t ≤ 50) is given on the first line of the input.
Subsequently, t datasets are given. Each dataset is given in two lines in the following format.
n k
x1 x2 ... xn
n is the number of houses and k is the number of generators. x1, x2, ..., xn are one-dimensional coordinates that represent the position of the house, respectively. All of these values are integers and satisfy 0 <n ≤ 100000, 0 <k ≤ 100000, 0 ≤ x1 <x2 <... <xn ≤ 1000000.
In addition, 90% of the dataset satisfies 0 <n ≤ 100, 0 <k ≤ 100.
Output
For each dataset, output the minimum total required wire length in one line.
Example
Input
6
5 2
10 30 40 70 100
7 3
3 6 10 17 21 26 28
1 1
100
2 1
0 1000000
3 5
30 70 150
6 4
0 10 20 30 40 50
Output
60
13
0
1000000
0
20
Submitted Solution:
```
trial = int(input())
for t in range(trial):
housecnt,elec = (int(n) for n in input().split(" "))
house = [int(n) for n in input().split(" ")]
maxlist = []
for h in range(housecnt-1):
maxlist.append(house[h+1]-house[h])
for p in range(elec-1):
maxlist.pop()
print(sum(maxlist))
``` | instruction | 0 | 74,909 | 3 | 149,818 |
No | output | 1 | 74,909 | 3 | 149,819 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
This is a story in a depopulated area. In this area, houses are sparsely built along a straight road called Country Road. Until now, there was no electricity in this area, but this time the government will give us some generators. You can install the generators wherever you like, but in order for electricity to be supplied to your home, you must be connected to one of the generators via an electric wire, which incurs a cost proportional to its length. As the only technical civil servant in the area, your job is to seek generator and wire placement that minimizes the total length of wires, provided that electricity is supplied to all homes. Is. Since the capacity of the generator is large enough, it is assumed that electricity can be supplied to as many houses as possible.
Figure 2 shows the first data set of the sample input. To give the optimum placement for this problem, place the generators at the positions x = 20 and x = 80 as shown in the figure, and draw the wires at the positions shown in gray in the figure, respectively.
Example of generator and wire placement (first dataset in input example).
---
Figure 2: Example of generator and wire placement (first dataset in input example).
Input
The number of datasets t (0 <t ≤ 50) is given on the first line of the input.
Subsequently, t datasets are given. Each dataset is given in two lines in the following format.
n k
x1 x2 ... xn
n is the number of houses and k is the number of generators. x1, x2, ..., xn are one-dimensional coordinates that represent the position of the house, respectively. All of these values are integers and satisfy 0 <n ≤ 100000, 0 <k ≤ 100000, 0 ≤ x1 <x2 <... <xn ≤ 1000000.
In addition, 90% of the dataset satisfies 0 <n ≤ 100, 0 <k ≤ 100.
Output
For each dataset, output the minimum total required wire length in one line.
Example
Input
6
5 2
10 30 40 70 100
7 3
3 6 10 17 21 26 28
1 1
100
2 1
0 1000000
3 5
30 70 150
6 4
0 10 20 30 40 50
Output
60
13
0
1000000
0
20
Submitted Solution:
```
n,k=map(int,input().split())
l=list(map(int,input().split()))
l1=[]
for i in range(n-1):
l1.append(l[i+1]-l[i])
l1=sorted(l1)
for i in range(k-1):
del l1[-1]
s=0
for i in l1:
s+=i
print(s)
``` | instruction | 0 | 74,910 | 3 | 149,820 |
No | output | 1 | 74,910 | 3 | 149,821 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
This is a story in a depopulated area. In this area, houses are sparsely built along a straight road called Country Road. Until now, there was no electricity in this area, but this time the government will give us some generators. You can install the generators wherever you like, but in order for electricity to be supplied to your home, you must be connected to one of the generators via an electric wire, which incurs a cost proportional to its length. As the only technical civil servant in the area, your job is to seek generator and wire placement that minimizes the total length of wires, provided that electricity is supplied to all homes. Is. Since the capacity of the generator is large enough, it is assumed that electricity can be supplied to as many houses as possible.
Figure 2 shows the first data set of the sample input. To give the optimum placement for this problem, place the generators at the positions x = 20 and x = 80 as shown in the figure, and draw the wires at the positions shown in gray in the figure, respectively.
Example of generator and wire placement (first dataset in input example).
---
Figure 2: Example of generator and wire placement (first dataset in input example).
Input
The number of datasets t (0 <t ≤ 50) is given on the first line of the input.
Subsequently, t datasets are given. Each dataset is given in two lines in the following format.
n k
x1 x2 ... xn
n is the number of houses and k is the number of generators. x1, x2, ..., xn are one-dimensional coordinates that represent the position of the house, respectively. All of these values are integers and satisfy 0 <n ≤ 100000, 0 <k ≤ 100000, 0 ≤ x1 <x2 <... <xn ≤ 1000000.
In addition, 90% of the dataset satisfies 0 <n ≤ 100, 0 <k ≤ 100.
Output
For each dataset, output the minimum total required wire length in one line.
Example
Input
6
5 2
10 30 40 70 100
7 3
3 6 10 17 21 26 28
1 1
100
2 1
0 1000000
3 5
30 70 150
6 4
0 10 20 30 40 50
Output
60
13
0
1000000
0
20
Submitted Solution:
```
o = int(input())
x = 0
while x < o+1: #最初の数字は集合のの数
N,K = map(int,input().strip().split(' '))
X = list(map(int,input().strip().split(' ')))#リストを作る
if N < K:
K = N
for i in range(N):
X.sort()
a = X[N-1] - X[0] #全体の長さ
Y = [0]*(N-1) #各家の間の距離の集合
for j in range(N-1):
Y[j] = X[j+1] - X[j]
Y.sort()
Z = a
for i in range(K-1): #一番遠い（大きい）のをK-1回外す
Z = Z - Y[N-1-1-i]
print(Z)
x = x+1
``` | instruction | 0 | 74,911 | 3 | 149,822 |
No | output | 1 | 74,911 | 3 | 149,823 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
Let's say you are standing on the XY-plane at point (0, 0) and you want to reach point (n, n).
You can move only in two directions:
* to the right, i. e. horizontally and in the direction that increase your x coordinate,
* or up, i. e. vertically and in the direction that increase your y coordinate.
In other words, your path will have the following structure:
* initially, you choose to go to the right or up;
* then you go some positive integer distance in the chosen direction (distances can be chosen independently);
* after that you change your direction (from right to up, or from up to right) and repeat the process.
You don't like to change your direction too much, so you will make no more than n - 1 direction changes.
As a result, your path will be a polygonal chain from (0, 0) to (n, n), consisting of at most n line segments where each segment has positive integer length and vertical and horizontal segments alternate.
Not all paths are equal. You have n integers c_1, c_2, ..., c_n where c_i is the cost of the i-th segment.
Using these costs we can define the cost of the path as the sum of lengths of the segments of this path multiplied by their cost, i. e. if the path consists of k segments (k ≤ n), then the cost of the path is equal to ∑_{i=1}^{k}{c_i ⋅ length_i} (segments are numbered from 1 to k in the order they are in the path).
Find the path of the minimum cost and print its cost.
Input
The first line contains the single integer t (1 ≤ t ≤ 1000) — the number of test cases.
The first line of each test case contains the single integer n (2 ≤ n ≤ 10^5).
The second line of each test case contains n integers c_1, c_2, ..., c_n (1 ≤ c_i ≤ 10^9) — the costs of each segment.
It's guaranteed that the total sum of n doesn't exceed 10^5.
Output
For each test case, print the minimum possible cost of the path from (0, 0) to (n, n) consisting of at most n alternating segments.
Example
Input
3
2
13 88
3
2 3 1
5
4 3 2 1 4
Output
202
13
19
Note
In the first test case, to reach (2, 2) you need to make at least one turn, so your path will consist of exactly 2 segments: one horizontal of length 2 and one vertical of length 2. The cost of the path will be equal to 2 ⋅ c_1 + 2 ⋅ c_2 = 26 + 176 = 202.
In the second test case, one of the optimal paths consists of 3 segments: the first segment of length 1, the second segment of length 3 and the third segment of length 2.
The cost of the path is 1 ⋅ 2 + 3 ⋅ 3 + 2 ⋅ 1 = 13.
In the third test case, one of the optimal paths consists of 4 segments: the first segment of length 1, the second one — 1, the third one — 4, the fourth one — 4. The cost of the path is 1 ⋅ 4 + 1 ⋅ 3 + 4 ⋅ 2 + 4 ⋅ 1 = 19.
Submitted Solution:
```
for s in[*open(0)][2::2]:
l=[*map(int,s.split())]
q=l[::2];qn=len(q)
w=l[1::2];wn=len(w)
n=len(l)
c=[]
s=[0,0]
m=[1e15,1e15]
p=[n,n]
for i in range(n):
x=i&1
m[x]=min(m[x],l[i])
s[x]+=l[i]
p[x]-=1
c+=[s[x]+p[x]*m[x]]
print(min(x+y for x,y in zip(c,c[1:])))
``` | instruction | 0 | 75,263 | 3 | 150,526 |
Yes | output | 1 | 75,263 | 3 | 150,527 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
Let's say you are standing on the XY-plane at point (0, 0) and you want to reach point (n, n).
You can move only in two directions:
* to the right, i. e. horizontally and in the direction that increase your x coordinate,
* or up, i. e. vertically and in the direction that increase your y coordinate.
In other words, your path will have the following structure:
* initially, you choose to go to the right or up;
* then you go some positive integer distance in the chosen direction (distances can be chosen independently);
* after that you change your direction (from right to up, or from up to right) and repeat the process.
You don't like to change your direction too much, so you will make no more than n - 1 direction changes.
As a result, your path will be a polygonal chain from (0, 0) to (n, n), consisting of at most n line segments where each segment has positive integer length and vertical and horizontal segments alternate.
Not all paths are equal. You have n integers c_1, c_2, ..., c_n where c_i is the cost of the i-th segment.
Using these costs we can define the cost of the path as the sum of lengths of the segments of this path multiplied by their cost, i. e. if the path consists of k segments (k ≤ n), then the cost of the path is equal to ∑_{i=1}^{k}{c_i ⋅ length_i} (segments are numbered from 1 to k in the order they are in the path).
Find the path of the minimum cost and print its cost.
Input
The first line contains the single integer t (1 ≤ t ≤ 1000) — the number of test cases.
The first line of each test case contains the single integer n (2 ≤ n ≤ 10^5).
The second line of each test case contains n integers c_1, c_2, ..., c_n (1 ≤ c_i ≤ 10^9) — the costs of each segment.
It's guaranteed that the total sum of n doesn't exceed 10^5.
Output
For each test case, print the minimum possible cost of the path from (0, 0) to (n, n) consisting of at most n alternating segments.
Example
Input
3
2
13 88
3
2 3 1
5
4 3 2 1 4
Output
202
13
19
Note
In the first test case, to reach (2, 2) you need to make at least one turn, so your path will consist of exactly 2 segments: one horizontal of length 2 and one vertical of length 2. The cost of the path will be equal to 2 ⋅ c_1 + 2 ⋅ c_2 = 26 + 176 = 202.
In the second test case, one of the optimal paths consists of 3 segments: the first segment of length 1, the second segment of length 3 and the third segment of length 2.
The cost of the path is 1 ⋅ 2 + 3 ⋅ 3 + 2 ⋅ 1 = 13.
In the third test case, one of the optimal paths consists of 4 segments: the first segment of length 1, the second one — 1, the third one — 4, the fourth one — 4. The cost of the path is 1 ⋅ 4 + 1 ⋅ 3 + 4 ⋅ 2 + 4 ⋅ 1 = 19.
Submitted Solution:
```
import sys
input=sys.stdin.readline
I = lambda : list(map(int,input().split()))
def ans(ar,n):
mi=ar[0]
ix=0
pre=ar[0]
bmi=ar[1]
bix=1
bpre=ar[1]
su=n*(ar[0]+ar[1])
for i in range(2,n):
if (i+1)%2:
if mi>ar[i]:
mi=ar[i]
ix=i
pre+=ar[i]
ax,bx=i//2+1,i//2
su=min(su,mi*(n-ax)+pre+bmi*(n-bx)+bpre)
#print(su,ax,bx)
#if i+2<n:
# pre+=ar[i+2]
else:
if bmi>ar[i]:
bmi=ar[i]
bix=i
bpre+=ar[i]
ax,bx=(i+1)//2,(i+1)//2
su=min(su,mi*(n-ax)+pre+bmi*(n-bx)+bpre)
#print(su,ax,bx)
return su
t,=I()
for _ in range(t):
n,=I()
ct=I()
print(ans(ct,n))
``` | instruction | 0 | 75,264 | 3 | 150,528 |
Yes | output | 1 | 75,264 | 3 | 150,529 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
Let's say you are standing on the XY-plane at point (0, 0) and you want to reach point (n, n).
You can move only in two directions:
* to the right, i. e. horizontally and in the direction that increase your x coordinate,
* or up, i. e. vertically and in the direction that increase your y coordinate.
In other words, your path will have the following structure:
* initially, you choose to go to the right or up;
* then you go some positive integer distance in the chosen direction (distances can be chosen independently);
* after that you change your direction (from right to up, or from up to right) and repeat the process.
You don't like to change your direction too much, so you will make no more than n - 1 direction changes.
As a result, your path will be a polygonal chain from (0, 0) to (n, n), consisting of at most n line segments where each segment has positive integer length and vertical and horizontal segments alternate.
Not all paths are equal. You have n integers c_1, c_2, ..., c_n where c_i is the cost of the i-th segment.
Using these costs we can define the cost of the path as the sum of lengths of the segments of this path multiplied by their cost, i. e. if the path consists of k segments (k ≤ n), then the cost of the path is equal to ∑_{i=1}^{k}{c_i ⋅ length_i} (segments are numbered from 1 to k in the order they are in the path).
Find the path of the minimum cost and print its cost.
Input
The first line contains the single integer t (1 ≤ t ≤ 1000) — the number of test cases.
The first line of each test case contains the single integer n (2 ≤ n ≤ 10^5).
The second line of each test case contains n integers c_1, c_2, ..., c_n (1 ≤ c_i ≤ 10^9) — the costs of each segment.
It's guaranteed that the total sum of n doesn't exceed 10^5.
Output
For each test case, print the minimum possible cost of the path from (0, 0) to (n, n) consisting of at most n alternating segments.
Example
Input
3
2
13 88
3
2 3 1
5
4 3 2 1 4
Output
202
13
19
Note
In the first test case, to reach (2, 2) you need to make at least one turn, so your path will consist of exactly 2 segments: one horizontal of length 2 and one vertical of length 2. The cost of the path will be equal to 2 ⋅ c_1 + 2 ⋅ c_2 = 26 + 176 = 202.
In the second test case, one of the optimal paths consists of 3 segments: the first segment of length 1, the second segment of length 3 and the third segment of length 2.
The cost of the path is 1 ⋅ 2 + 3 ⋅ 3 + 2 ⋅ 1 = 13.
In the third test case, one of the optimal paths consists of 4 segments: the first segment of length 1, the second one — 1, the third one — 4, the fourth one — 4. The cost of the path is 1 ⋅ 4 + 1 ⋅ 3 + 4 ⋅ 2 + 4 ⋅ 1 = 19.
Submitted Solution:
```
import sys
from math import inf
for _ in range(int(input())):
n = int(input())
arr = list(map(int,sys.stdin.readline().split()))
vert = []
hori = []
for i in range(n):
if i%2 == 0:
vert.append(arr[i])
else:
hori.append(arr[i])
vert_sum = [0 for _ in range((n+1)//2)]
hori_sum = [0 for _ in range(n//2)]
now = n-1
now_sum = 0
mini = inf
for i in range((n+1)//2):
if vert[i] < mini:
mini = vert[i]
now_sum += vert[i]
vert_sum[i] = now_sum + mini * now
now -= 1
now = n-1
now_sum = 0
mini = inf
for i in range(n//2):
if hori[i] < mini:
mini = hori[i]
now_sum += hori[i]
hori_sum[i] = now_sum + mini * now
now -= 1
dp = [0 for i in range(n-1)]
dp[0] = hori_sum[0] + vert_sum[0]
for i in range(1,n-1):
dp[i] = vert_sum[(i+1)//2] + hori_sum[i//2]
print(min(dp))
``` | instruction | 0 | 75,265 | 3 | 150,530 |
Yes | output | 1 | 75,265 | 3 | 150,531 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
Let's say you are standing on the XY-plane at point (0, 0) and you want to reach point (n, n).
You can move only in two directions:
* to the right, i. e. horizontally and in the direction that increase your x coordinate,
* or up, i. e. vertically and in the direction that increase your y coordinate.
In other words, your path will have the following structure:
* initially, you choose to go to the right or up;
* then you go some positive integer distance in the chosen direction (distances can be chosen independently);
* after that you change your direction (from right to up, or from up to right) and repeat the process.
You don't like to change your direction too much, so you will make no more than n - 1 direction changes.
As a result, your path will be a polygonal chain from (0, 0) to (n, n), consisting of at most n line segments where each segment has positive integer length and vertical and horizontal segments alternate.
Not all paths are equal. You have n integers c_1, c_2, ..., c_n where c_i is the cost of the i-th segment.
Using these costs we can define the cost of the path as the sum of lengths of the segments of this path multiplied by their cost, i. e. if the path consists of k segments (k ≤ n), then the cost of the path is equal to ∑_{i=1}^{k}{c_i ⋅ length_i} (segments are numbered from 1 to k in the order they are in the path).
Find the path of the minimum cost and print its cost.
Input
The first line contains the single integer t (1 ≤ t ≤ 1000) — the number of test cases.
The first line of each test case contains the single integer n (2 ≤ n ≤ 10^5).
The second line of each test case contains n integers c_1, c_2, ..., c_n (1 ≤ c_i ≤ 10^9) — the costs of each segment.
It's guaranteed that the total sum of n doesn't exceed 10^5.
Output
For each test case, print the minimum possible cost of the path from (0, 0) to (n, n) consisting of at most n alternating segments.
Example
Input
3
2
13 88
3
2 3 1
5
4 3 2 1 4
Output
202
13
19
Note
In the first test case, to reach (2, 2) you need to make at least one turn, so your path will consist of exactly 2 segments: one horizontal of length 2 and one vertical of length 2. The cost of the path will be equal to 2 ⋅ c_1 + 2 ⋅ c_2 = 26 + 176 = 202.
In the second test case, one of the optimal paths consists of 3 segments: the first segment of length 1, the second segment of length 3 and the third segment of length 2.
The cost of the path is 1 ⋅ 2 + 3 ⋅ 3 + 2 ⋅ 1 = 13.
In the third test case, one of the optimal paths consists of 4 segments: the first segment of length 1, the second one — 1, the third one — 4, the fourth one — 4. The cost of the path is 1 ⋅ 4 + 1 ⋅ 3 + 4 ⋅ 2 + 4 ⋅ 1 = 19.
Submitted Solution:
```
t = int(input())
for _ in range(t):
n = int(input())
costs = input().split()
costs = [int(item) for item in costs]
minPathCost = (costs[0] + costs[1]) * n
horizSum = 0
vertSum = 0
minHoriz = 10 ** 10
minVert = 10 ** 10
numHoriz = 0
numVert = 0
for i in range(n):
if i % 2 == 0:
horizSum += costs[i]
minHoriz = min(minHoriz, costs[i])
numHoriz += 1
if i % 2 != 0:
vertSum += costs[i]
minVert = min(minVert, costs[i])
numVert += 1
goodSum = minHoriz * (n - numHoriz) + minVert * (n - numVert) + horizSum + vertSum
minPathCost = min(minPathCost, goodSum)
print(minPathCost)
``` | instruction | 0 | 75,266 | 3 | 150,532 |
Yes | output | 1 | 75,266 | 3 | 150,533 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
Let's say you are standing on the XY-plane at point (0, 0) and you want to reach point (n, n).
You can move only in two directions:
* to the right, i. e. horizontally and in the direction that increase your x coordinate,
* or up, i. e. vertically and in the direction that increase your y coordinate.
In other words, your path will have the following structure:
* initially, you choose to go to the right or up;
* then you go some positive integer distance in the chosen direction (distances can be chosen independently);
* after that you change your direction (from right to up, or from up to right) and repeat the process.
You don't like to change your direction too much, so you will make no more than n - 1 direction changes.
As a result, your path will be a polygonal chain from (0, 0) to (n, n), consisting of at most n line segments where each segment has positive integer length and vertical and horizontal segments alternate.
Not all paths are equal. You have n integers c_1, c_2, ..., c_n where c_i is the cost of the i-th segment.
Using these costs we can define the cost of the path as the sum of lengths of the segments of this path multiplied by their cost, i. e. if the path consists of k segments (k ≤ n), then the cost of the path is equal to ∑_{i=1}^{k}{c_i ⋅ length_i} (segments are numbered from 1 to k in the order they are in the path).
Find the path of the minimum cost and print its cost.
Input
The first line contains the single integer t (1 ≤ t ≤ 1000) — the number of test cases.
The first line of each test case contains the single integer n (2 ≤ n ≤ 10^5).
The second line of each test case contains n integers c_1, c_2, ..., c_n (1 ≤ c_i ≤ 10^9) — the costs of each segment.
It's guaranteed that the total sum of n doesn't exceed 10^5.
Output
For each test case, print the minimum possible cost of the path from (0, 0) to (n, n) consisting of at most n alternating segments.
Example
Input
3
2
13 88
3
2 3 1
5
4 3 2 1 4
Output
202
13
19
Note
In the first test case, to reach (2, 2) you need to make at least one turn, so your path will consist of exactly 2 segments: one horizontal of length 2 and one vertical of length 2. The cost of the path will be equal to 2 ⋅ c_1 + 2 ⋅ c_2 = 26 + 176 = 202.
In the second test case, one of the optimal paths consists of 3 segments: the first segment of length 1, the second segment of length 3 and the third segment of length 2.
The cost of the path is 1 ⋅ 2 + 3 ⋅ 3 + 2 ⋅ 1 = 13.
In the third test case, one of the optimal paths consists of 4 segments: the first segment of length 1, the second one — 1, the third one — 4, the fourth one — 4. The cost of the path is 1 ⋅ 4 + 1 ⋅ 3 + 4 ⋅ 2 + 4 ⋅ 1 = 19.
Submitted Solution:
```
for _ in range(int(input())):
n = int(input())
arr = list(map(int,input().split()))
count = arr[0]*n + arr[1]*n
mi0 = arr[0]
mi1 = arr[1]
ma0 = arr[0]
ma1 = arr[1]
dp = [count]
mi0_count = n
mi1_count = n
for i in range(2,n):
if(i%2 == 0):
if(arr[i]<=mi0):
count-=(mi0_count)*mi0
count+=mi0
mi0_count-=1
mi0 = arr[i]
count+=mi0_count*mi0
elif(arr[i]>mi0 and arr[i]<ma0):
mi0_count-=1
count-=mi0
count+=arr[i]
else:
arr[i] = ma0
count-=mi0
count+=ma0
mi0_count-=1
else:
if(arr[i]<=mi1):
count-=(mi1_count)*mi1
count+=mi1
mi1_count-=1
mi1 = arr[i]
count+=mi1_count*mi1
elif(arr[i]>mi1 and arr[i]<ma1):
mi1_count-=1
count-=mi1
count+=arr[i]
else:
arr[i] = ma1
count-=mi1
count+=ma1
mi1_count-=1
dp.append(count)
print(min(dp))
``` | instruction | 0 | 75,267 | 3 | 150,534 |
No | output | 1 | 75,267 | 3 | 150,535 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
Let's say you are standing on the XY-plane at point (0, 0) and you want to reach point (n, n).
You can move only in two directions:
* to the right, i. e. horizontally and in the direction that increase your x coordinate,
* or up, i. e. vertically and in the direction that increase your y coordinate.
In other words, your path will have the following structure:
* initially, you choose to go to the right or up;
* then you go some positive integer distance in the chosen direction (distances can be chosen independently);
* after that you change your direction (from right to up, or from up to right) and repeat the process.
You don't like to change your direction too much, so you will make no more than n - 1 direction changes.
As a result, your path will be a polygonal chain from (0, 0) to (n, n), consisting of at most n line segments where each segment has positive integer length and vertical and horizontal segments alternate.
Not all paths are equal. You have n integers c_1, c_2, ..., c_n where c_i is the cost of the i-th segment.
Using these costs we can define the cost of the path as the sum of lengths of the segments of this path multiplied by their cost, i. e. if the path consists of k segments (k ≤ n), then the cost of the path is equal to ∑_{i=1}^{k}{c_i ⋅ length_i} (segments are numbered from 1 to k in the order they are in the path).
Find the path of the minimum cost and print its cost.
Input
The first line contains the single integer t (1 ≤ t ≤ 1000) — the number of test cases.
The first line of each test case contains the single integer n (2 ≤ n ≤ 10^5).
The second line of each test case contains n integers c_1, c_2, ..., c_n (1 ≤ c_i ≤ 10^9) — the costs of each segment.
It's guaranteed that the total sum of n doesn't exceed 10^5.
Output
For each test case, print the minimum possible cost of the path from (0, 0) to (n, n) consisting of at most n alternating segments.
Example
Input
3
2
13 88
3
2 3 1
5
4 3 2 1 4
Output
202
13
19
Note
In the first test case, to reach (2, 2) you need to make at least one turn, so your path will consist of exactly 2 segments: one horizontal of length 2 and one vertical of length 2. The cost of the path will be equal to 2 ⋅ c_1 + 2 ⋅ c_2 = 26 + 176 = 202.
In the second test case, one of the optimal paths consists of 3 segments: the first segment of length 1, the second segment of length 3 and the third segment of length 2.
The cost of the path is 1 ⋅ 2 + 3 ⋅ 3 + 2 ⋅ 1 = 13.
In the third test case, one of the optimal paths consists of 4 segments: the first segment of length 1, the second one — 1, the third one — 4, the fourth one — 4. The cost of the path is 1 ⋅ 4 + 1 ⋅ 3 + 4 ⋅ 2 + 4 ⋅ 1 = 19.
Submitted Solution:
```
import sys
import bisect
input_=lambda: sys.stdin.readline().strip("\r\n")
from math import log
sa=lambda :input_()
sb=lambda:int(input_())
sc=lambda:input_().split()
sd=lambda:list(map(int,input_().split()))
se=lambda:float(input_())
sf=lambda:list(input_())
flsh=lambda: sys.stdout.flush()
mod=10**9+7
def hnbhai():
n=sb()
c=sd()
cost=n*c[0]+n*c[1]
#print(cost)
s=0
x=0
y=0
for i in range(1,n):
cost=min(cost,c[i]*(n-x)+c[i-1]*(n-y)+s)
s+=c[i-1]
#print(i,s)
if i%2:
x+=1
else:
y+=1
print(cost)
for _ in range(sb()):
hnbhai()
``` | instruction | 0 | 75,268 | 3 | 150,536 |
No | output | 1 | 75,268 | 3 | 150,537 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
Let's say you are standing on the XY-plane at point (0, 0) and you want to reach point (n, n).
You can move only in two directions:
* to the right, i. e. horizontally and in the direction that increase your x coordinate,
* or up, i. e. vertically and in the direction that increase your y coordinate.
In other words, your path will have the following structure:
* initially, you choose to go to the right or up;
* then you go some positive integer distance in the chosen direction (distances can be chosen independently);
* after that you change your direction (from right to up, or from up to right) and repeat the process.
You don't like to change your direction too much, so you will make no more than n - 1 direction changes.
As a result, your path will be a polygonal chain from (0, 0) to (n, n), consisting of at most n line segments where each segment has positive integer length and vertical and horizontal segments alternate.
Not all paths are equal. You have n integers c_1, c_2, ..., c_n where c_i is the cost of the i-th segment.
Using these costs we can define the cost of the path as the sum of lengths of the segments of this path multiplied by their cost, i. e. if the path consists of k segments (k ≤ n), then the cost of the path is equal to ∑_{i=1}^{k}{c_i ⋅ length_i} (segments are numbered from 1 to k in the order they are in the path).
Find the path of the minimum cost and print its cost.
Input
The first line contains the single integer t (1 ≤ t ≤ 1000) — the number of test cases.
The first line of each test case contains the single integer n (2 ≤ n ≤ 10^5).
The second line of each test case contains n integers c_1, c_2, ..., c_n (1 ≤ c_i ≤ 10^9) — the costs of each segment.
It's guaranteed that the total sum of n doesn't exceed 10^5.
Output
For each test case, print the minimum possible cost of the path from (0, 0) to (n, n) consisting of at most n alternating segments.
Example
Input
3
2
13 88
3
2 3 1
5
4 3 2 1 4
Output
202
13
19
Note
In the first test case, to reach (2, 2) you need to make at least one turn, so your path will consist of exactly 2 segments: one horizontal of length 2 and one vertical of length 2. The cost of the path will be equal to 2 ⋅ c_1 + 2 ⋅ c_2 = 26 + 176 = 202.
In the second test case, one of the optimal paths consists of 3 segments: the first segment of length 1, the second segment of length 3 and the third segment of length 2.
The cost of the path is 1 ⋅ 2 + 3 ⋅ 3 + 2 ⋅ 1 = 13.
In the third test case, one of the optimal paths consists of 4 segments: the first segment of length 1, the second one — 1, the third one — 4, the fourth one — 4. The cost of the path is 1 ⋅ 4 + 1 ⋅ 3 + 4 ⋅ 2 + 4 ⋅ 1 = 19.
Submitted Solution:
```
t=int(input())
for i in range(t):
n=int(input())
l=list(map(int, input().split(" ")))
e=[]
o=[]
mine=1000000000
ne=-1
no=-1
mino=1000000000
pe=0
po=0
sum=0
if(i>=55):
print(n,l)
for i in range(n):
if(i%2==0):
e.append(l[i])
ne+=1
if(l[i]<mine):
mine=l[i]
pe=ne
else:
o.append(l[i])
no+=1
if(l[i]<mino) :
mino=l[i]
po=no
if(n%2!=0):
if(e[ne]<mine):
mine=e[ne]
pe=ne
#print(mine,mino,e,o)
#print(pe,po)
if(po>pe):
for i in range(po+1):
sum+=o[i]+e[i]
sum+=(n-po-1)*(mino+mine)
else:
numo=0
for i in range(pe+1):
sum+=e[i]
if(i<no+1):
sum+=o[i]
numo+=1
sum+=(n-pe-1)*(mine)
sum+=(n-numo)*mino
print(sum)
``` | instruction | 0 | 75,269 | 3 | 150,538 |
No | output | 1 | 75,269 | 3 | 150,539 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
Let's say you are standing on the XY-plane at point (0, 0) and you want to reach point (n, n).
You can move only in two directions:
* to the right, i. e. horizontally and in the direction that increase your x coordinate,
* or up, i. e. vertically and in the direction that increase your y coordinate.
In other words, your path will have the following structure:
* initially, you choose to go to the right or up;
* then you go some positive integer distance in the chosen direction (distances can be chosen independently);
* after that you change your direction (from right to up, or from up to right) and repeat the process.
You don't like to change your direction too much, so you will make no more than n - 1 direction changes.
As a result, your path will be a polygonal chain from (0, 0) to (n, n), consisting of at most n line segments where each segment has positive integer length and vertical and horizontal segments alternate.
Not all paths are equal. You have n integers c_1, c_2, ..., c_n where c_i is the cost of the i-th segment.
Using these costs we can define the cost of the path as the sum of lengths of the segments of this path multiplied by their cost, i. e. if the path consists of k segments (k ≤ n), then the cost of the path is equal to ∑_{i=1}^{k}{c_i ⋅ length_i} (segments are numbered from 1 to k in the order they are in the path).
Find the path of the minimum cost and print its cost.
Input
The first line contains the single integer t (1 ≤ t ≤ 1000) — the number of test cases.
The first line of each test case contains the single integer n (2 ≤ n ≤ 10^5).
The second line of each test case contains n integers c_1, c_2, ..., c_n (1 ≤ c_i ≤ 10^9) — the costs of each segment.
It's guaranteed that the total sum of n doesn't exceed 10^5.
Output
For each test case, print the minimum possible cost of the path from (0, 0) to (n, n) consisting of at most n alternating segments.
Example
Input
3
2
13 88
3
2 3 1
5
4 3 2 1 4
Output
202
13
19
Note
In the first test case, to reach (2, 2) you need to make at least one turn, so your path will consist of exactly 2 segments: one horizontal of length 2 and one vertical of length 2. The cost of the path will be equal to 2 ⋅ c_1 + 2 ⋅ c_2 = 26 + 176 = 202.
In the second test case, one of the optimal paths consists of 3 segments: the first segment of length 1, the second segment of length 3 and the third segment of length 2.
The cost of the path is 1 ⋅ 2 + 3 ⋅ 3 + 2 ⋅ 1 = 13.
In the third test case, one of the optimal paths consists of 4 segments: the first segment of length 1, the second one — 1, the third one — 4, the fourth one — 4. The cost of the path is 1 ⋅ 4 + 1 ⋅ 3 + 4 ⋅ 2 + 4 ⋅ 1 = 19.
Submitted Solution:
```
from sys import maxsize, stdout, stdin,stderr
mod = int(1e9 + 7)
def I(): return int(stdin.readline())
def lint(): return [int(x) for x in stdin.readline().split()]
def S(): return input().strip()
def grid(r, c): return [lint() for i in range(r)]
from collections import defaultdict
import math
t = I()
for _ in range(t):
n = I()
s = lint()
k = n
x = n
mx = s[0]*k
mi = s[1]*x
r=0
y=0
for i in range(0,n):
if i%2==0:
if mx> s[i]*k +r:
mx=s[i]*k +r
k-=1
r += s[i]
if r>mx:
break
if k==0:
break
else:
if mi> s[i]*x +y:
mi=s[i]*x + y
x-=1
y += s[i]
if y>mi:
break
if x==0:
break
#print(mi)
#print(mx)
#print(mi)
print(mi+mx)
``` | instruction | 0 | 75,270 | 3 | 150,540 |
No | output | 1 | 75,270 | 3 | 150,541 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
Meg the Rabbit decided to do something nice, specifically — to determine the shortest distance between two points on the surface of our planet. But Meg... what can you say, she wants everything simple. So, she already regards our planet as a two-dimensional circle. No, wait, it's even worse — as a square of side n. Thus, the task has been reduced to finding the shortest path between two dots on a square (the path should go through the square sides). To simplify the task let us consider the vertices of the square to lie at points whose coordinates are: (0, 0), (n, 0), (0, n) and (n, n).
Input
The single line contains 5 space-separated integers: n, x1, y1, x2, y2 (1 ≤ n ≤ 1000, 0 ≤ x1, y1, x2, y2 ≤ n) which correspondingly represent a side of the square, the coordinates of the first point and the coordinates of the second point. It is guaranteed that the points lie on the sides of the square.
Output
You must print on a single line the shortest distance between the points.
Examples
Input
2 0 0 1 0
Output
1
Input
2 0 1 2 1
Output
4
Input
100 0 0 100 100
Output
200
Submitted Solution:
```
import math
n, x1, y1, x2, y2 = [int(i) for i in input().split()]
obw = 4*n
dist_from_zero1 = 0
dist_from_zero2 = 0
# trzeba to rozbic na 4 cwiartki
if x1 == 0 and y1 >= 0:
dist_from_zero1 = x1 + y1
elif y1 == n and x1 != 0:
dist_from_zero1 = n + x1
elif x1 >= 0 and y1 == 0:
dist_from_zero1 = obw - x1
elif y1 != 0 and x1 == n:
dist_from_zero1 = 3*n - y1
if x2 == 0 and y2 >= 0:
dist_from_zero2 = x2 + y2
elif y2 == n and x2 != 0:
dist_from_zero2 = n + x2
elif x2 >= 0 and y2 == 0:
dist_from_zero2 = obw - x2
elif y2 != 0 and x2 == n:
dist_from_zero2 = 3*n - y2
print(min(int(math.fabs(dist_from_zero2 - dist_from_zero1)), int(obw - dist_from_zero1 + dist_from_zero2), int(obw - dist_from_zero2 + dist_from_zero1)))
``` | instruction | 0 | 75,488 | 3 | 150,976 |
Yes | output | 1 | 75,488 | 3 | 150,977 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
Meg the Rabbit decided to do something nice, specifically — to determine the shortest distance between two points on the surface of our planet. But Meg... what can you say, she wants everything simple. So, she already regards our planet as a two-dimensional circle. No, wait, it's even worse — as a square of side n. Thus, the task has been reduced to finding the shortest path between two dots on a square (the path should go through the square sides). To simplify the task let us consider the vertices of the square to lie at points whose coordinates are: (0, 0), (n, 0), (0, n) and (n, n).
Input
The single line contains 5 space-separated integers: n, x1, y1, x2, y2 (1 ≤ n ≤ 1000, 0 ≤ x1, y1, x2, y2 ≤ n) which correspondingly represent a side of the square, the coordinates of the first point and the coordinates of the second point. It is guaranteed that the points lie on the sides of the square.
Output
You must print on a single line the shortest distance between the points.
Examples
Input
2 0 0 1 0
Output
1
Input
2 0 1 2 1
Output
4
Input
100 0 0 100 100
Output
200
Submitted Solution:
```
n,x,y,p,q=map(int,input().split())
d=abs(x-p)+abs(y-q)
if(abs(x-p)==n):
d=min(n+y+q,3*n-(y+q))
if(abs(y-q)==n):
d=min(n+x+p,3*n-(x+p))
print(d)
``` | instruction | 0 | 75,490 | 3 | 150,980 |
Yes | output | 1 | 75,490 | 3 | 150,981 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
Meg the Rabbit decided to do something nice, specifically — to determine the shortest distance between two points on the surface of our planet. But Meg... what can you say, she wants everything simple. So, she already regards our planet as a two-dimensional circle. No, wait, it's even worse — as a square of side n. Thus, the task has been reduced to finding the shortest path between two dots on a square (the path should go through the square sides). To simplify the task let us consider the vertices of the square to lie at points whose coordinates are: (0, 0), (n, 0), (0, n) and (n, n).
Input
The single line contains 5 space-separated integers: n, x1, y1, x2, y2 (1 ≤ n ≤ 1000, 0 ≤ x1, y1, x2, y2 ≤ n) which correspondingly represent a side of the square, the coordinates of the first point and the coordinates of the second point. It is guaranteed that the points lie on the sides of the square.
Output
You must print on a single line the shortest distance between the points.
Examples
Input
2 0 0 1 0
Output
1
Input
2 0 1 2 1
Output
4
Input
100 0 0 100 100
Output
200
Submitted Solution:
```
n,x,y,xx,yy=[int(i) for i in input().split()]
if x+xx==0:
res=yy-y
elif y+yy==0:
res=xx-x
elif x==n and xx==0 or xx==n and x==0:
if y+yy>n+n-y-yy:
su=n+n-y-yy
else:
su=y+yy
res=n+su
elif y==n and yy==0 or yy==n and y==0:
if x+xx>n+n-x-xx:
su=n+n-x-xx
else:
su=x+xx
res=n+su
elif y==xx==n or yy==x==n:
res=4*n-x-xx-y-yy
#elif y==xx==0 or yy==x==0:
# res=4*n-x-xx-y-yy
#elif x+yy==n or xx+y==n:
# res=x+y-xx-yy
elif x==xx:
res=yy-y
elif y==yy:
res=x-xx
elif (x+yy==n or xx+y==n) and (y==0 or yy==0):
res=xx+x+y+yy-n
elif (x+yy==n or xx+y==n) and (x==0 or x==0):
res=x+y-xx-yy
else:
res=x+xx+y+yy
if 2*n-res>res:
res=2*n-res
if res<0:
print(-res)
else:
print(res)
``` | instruction | 0 | 75,494 | 3 | 150,988 |
No | output | 1 | 75,494 | 3 | 150,989 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
Meg the Rabbit decided to do something nice, specifically — to determine the shortest distance between two points on the surface of our planet. But Meg... what can you say, she wants everything simple. So, she already regards our planet as a two-dimensional circle. No, wait, it's even worse — as a square of side n. Thus, the task has been reduced to finding the shortest path between two dots on a square (the path should go through the square sides). To simplify the task let us consider the vertices of the square to lie at points whose coordinates are: (0, 0), (n, 0), (0, n) and (n, n).
Input
The single line contains 5 space-separated integers: n, x1, y1, x2, y2 (1 ≤ n ≤ 1000, 0 ≤ x1, y1, x2, y2 ≤ n) which correspondingly represent a side of the square, the coordinates of the first point and the coordinates of the second point. It is guaranteed that the points lie on the sides of the square.
Output
You must print on a single line the shortest distance between the points.
Examples
Input
2 0 0 1 0
Output
1
Input
2 0 1 2 1
Output
4
Input
100 0 0 100 100
Output
200
Submitted Solution:
```
import math
n, x1, y1, x2, y2 = [int(i) for i in input().split()]
obw = 4*n
dist_from_zero1 = 0
dist_from_zero2 = 0
if x1 >= y1:
dist_from_zero1 = x1 + y1
elif x1 < y1:
dist_from_zero1 = obw - x1 - y1
if x2 >= y2:
dist_from_zero2 = x2 + y2
elif x2 < y2:
dist_from_zero2 = obw - x2 - y2
print(int(math.fabs(dist_from_zero2-dist_from_zero1)))
``` | instruction | 0 | 75,495 | 3 | 150,990 |
No | output | 1 | 75,495 | 3 | 150,991 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
Programmer Sasha is a student at MIPT (Moscow Institute of Physics and Technology) and he needs to make a laboratory work to pass his finals.
A laboratory unit is a plane with standard coordinate axes marked on it. Physicists from Moscow Institute of Physics and Technology charged the axes by large electric charges: axis X is positive and axis Y is negative.
Experienced laboratory worker marked n points with integer coordinates (xi, yi) on the plane and stopped the time. Sasha should use "atomic tweezers" to place elementary particles in these points. He has an unlimited number of electrons (negatively charged elementary particles) and protons (positively charged elementary particles). He can put either an electron or a proton at each marked point. As soon as all marked points are filled with particles, laboratory worker will turn on the time again and the particles will come in motion and after some time they will stabilize in equilibrium. The objective of the laboratory work is to arrange the particles in such a way, that the diameter of the resulting state (the maximum distance between the pairs of points of the set) is as small as possible.
Since Sasha is a programmer, he naively thinks that all the particles will simply "fall" into their projections on the corresponding axes: electrons will fall on axis X, while protons will fall on axis Y. As we are programmers too, we will consider the same model as Sasha. That is, a particle gets from point (x, y) to point (x, 0) if it is an electron and to point (0, y) if it is a proton.
As the laboratory has high background radiation and Sasha takes care of his laptop, he did not take it with him, and now he can't write a program that computes the minimum possible diameter of the resulting set. Therefore, you will have to do it for him.
Print a square of the minimum possible diameter of the set.
Input
The first line of the input contains a single integer n (1 ≤ n ≤ 100 000) — the number of points marked on the plane.
Each of the next n lines contains two integers xi and yi ( - 108 ≤ xi, yi ≤ 108) — the coordinates of the i-th point. It is guaranteed that no two points coincide.
Output
Print a single integer — the square of the minimum possible diameter of the set.
Examples
Input
3
1 10
1 20
1 30
Output
0
Input
2
1 10
10 1
Output
2
Note
In the first sample Sasha puts electrons at all points, all particles eventually fall at a single point (1, 0).
In the second sample Sasha puts an electron at point (1, 10), and a proton at point (10, 1). The result is a set of two points (1, 0) and (0, 1), which has a diameter of <image>.
Submitted Solution:
```
import sys
input = sys.stdin.readline
INF = 2 * 10 ** 8
n = int(input())
p = []
for i in range(n):
xx, yy = map(int, input().split())
p.append((xx,yy))
p.sort()
prefmin = [INF]
prefmax = [-INF]
for _,v in p:
prefmin.append(min(prefmin[-1],v))
prefmax.append(max(prefmax[-1],v))
revp = p[::-1]
suffmin = [INF]
suffmax = [-INF]
for _,v in revp:
suffmin.append(min(suffmin[-1],v))
suffmax.append(max(suffmax[-1],v))
counter = 0
lo = -1
hi = min((max(pp[1] for pp in p) - min(pp[1] for pp in p)) ** 2, (max(pp[0] for pp in p) - min(pp[0] for pp in p)) ** 2)
while hi - lo > 1:
test = (hi + lo) // 2
h = -1
works = False
for l in range(n):
while h < n-1 and p[h+1][0] ** 2 <= p[l][0] ** 2 and (p[h + 1][0] - p[l][0]) ** 2 <= test:
h += 1
counter += 1
while p[h][0] ** 2 > p[l][0] ** 2 or (p[h][0] - p[l][0]) ** 2 > test:
h -= 1
counter += 1
ys = min(prefmin[l], suffmin[n-h-1])
yl = max(prefmax[l], suffmax[n-h-1])
xc = max(p[l][0] ** 2, p[h][0] ** 2)
assert(xc == p[l][0] ** 2)
yc = max(ys ** 2, yl ** 2)
if xc + yc <= test and (ys - yl) ** 2 <= test:
#print(l,h,test)
works = True
break
test = (hi + lo) // 2
h = -1
for l in range(n):
while h < n-1 and revp[h+1][0] ** 2 <= revp[l][0] ** 2 and (revp[h + 1][0] - revp[l][0]) ** 2 <= test:
h += 1
counter += 1
while revp[h][0] ** 2 > revp[l][0] ** 2 or (revp[h][0] - revp[l][0]) ** 2 > test:
h -= 1
counter += 1
ys = min(suffmin[l], prefmin[n-h-1])
yl = max(suffmax[l], prefmax[n-h-1])
xc = max(revp[l][0] ** 2, revp[h][0] ** 2)
assert(xc == revp[l][0] ** 2)
yc = max(ys ** 2, yl ** 2)
if xc + yc <= test and (ys - yl) ** 2 <= test:
#print(l,h,test)
works = True
break
if counter > 100000:
print('SLOW')
exit()
if works:
hi = test
else:
lo = test
print(hi)
``` | instruction | 0 | 75,500 | 3 | 151,000 |
No | output | 1 | 75,500 | 3 | 151,001 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
Programmer Sasha is a student at MIPT (Moscow Institute of Physics and Technology) and he needs to make a laboratory work to pass his finals.
A laboratory unit is a plane with standard coordinate axes marked on it. Physicists from Moscow Institute of Physics and Technology charged the axes by large electric charges: axis X is positive and axis Y is negative.
Experienced laboratory worker marked n points with integer coordinates (xi, yi) on the plane and stopped the time. Sasha should use "atomic tweezers" to place elementary particles in these points. He has an unlimited number of electrons (negatively charged elementary particles) and protons (positively charged elementary particles). He can put either an electron or a proton at each marked point. As soon as all marked points are filled with particles, laboratory worker will turn on the time again and the particles will come in motion and after some time they will stabilize in equilibrium. The objective of the laboratory work is to arrange the particles in such a way, that the diameter of the resulting state (the maximum distance between the pairs of points of the set) is as small as possible.
Since Sasha is a programmer, he naively thinks that all the particles will simply "fall" into their projections on the corresponding axes: electrons will fall on axis X, while protons will fall on axis Y. As we are programmers too, we will consider the same model as Sasha. That is, a particle gets from point (x, y) to point (x, 0) if it is an electron and to point (0, y) if it is a proton.
As the laboratory has high background radiation and Sasha takes care of his laptop, he did not take it with him, and now he can't write a program that computes the minimum possible diameter of the resulting set. Therefore, you will have to do it for him.
Print a square of the minimum possible diameter of the set.
Input
The first line of the input contains a single integer n (1 ≤ n ≤ 100 000) — the number of points marked on the plane.
Each of the next n lines contains two integers xi and yi ( - 108 ≤ xi, yi ≤ 108) — the coordinates of the i-th point. It is guaranteed that no two points coincide.
Output
Print a single integer — the square of the minimum possible diameter of the set.
Examples
Input
3
1 10
1 20
1 30
Output
0
Input
2
1 10
10 1
Output
2
Note
In the first sample Sasha puts electrons at all points, all particles eventually fall at a single point (1, 0).
In the second sample Sasha puts an electron at point (1, 10), and a proton at point (10, 1). The result is a set of two points (1, 0) and (0, 1), which has a diameter of <image>.
Submitted Solution:
```
from math import *
n = int(input())
x1,y1,x2,y2=-10**10,0,0,-10**10
for i in range(n):
a,b = map(int,input().split())
if a<b:
b = 0
else:
a = 0
if x1<a:
x1 = a
y1 = b
if y2<b:
y2 = b
x2 = a
if [x1,y1]==[x2,y2]:
print(0)
quit()
print(round(sqrt( (x1)**2 + (y2)**2 )**2))
``` | instruction | 0 | 75,501 | 3 | 151,002 |
No | output | 1 | 75,501 | 3 | 151,003 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
Programmer Sasha is a student at MIPT (Moscow Institute of Physics and Technology) and he needs to make a laboratory work to pass his finals.
A laboratory unit is a plane with standard coordinate axes marked on it. Physicists from Moscow Institute of Physics and Technology charged the axes by large electric charges: axis X is positive and axis Y is negative.
Experienced laboratory worker marked n points with integer coordinates (xi, yi) on the plane and stopped the time. Sasha should use "atomic tweezers" to place elementary particles in these points. He has an unlimited number of electrons (negatively charged elementary particles) and protons (positively charged elementary particles). He can put either an electron or a proton at each marked point. As soon as all marked points are filled with particles, laboratory worker will turn on the time again and the particles will come in motion and after some time they will stabilize in equilibrium. The objective of the laboratory work is to arrange the particles in such a way, that the diameter of the resulting state (the maximum distance between the pairs of points of the set) is as small as possible.
Since Sasha is a programmer, he naively thinks that all the particles will simply "fall" into their projections on the corresponding axes: electrons will fall on axis X, while protons will fall on axis Y. As we are programmers too, we will consider the same model as Sasha. That is, a particle gets from point (x, y) to point (x, 0) if it is an electron and to point (0, y) if it is a proton.
As the laboratory has high background radiation and Sasha takes care of his laptop, he did not take it with him, and now he can't write a program that computes the minimum possible diameter of the resulting set. Therefore, you will have to do it for him.
Print a square of the minimum possible diameter of the set.
Input
The first line of the input contains a single integer n (1 ≤ n ≤ 100 000) — the number of points marked on the plane.
Each of the next n lines contains two integers xi and yi ( - 108 ≤ xi, yi ≤ 108) — the coordinates of the i-th point. It is guaranteed that no two points coincide.
Output
Print a single integer — the square of the minimum possible diameter of the set.
Examples
Input
3
1 10
1 20
1 30
Output
0
Input
2
1 10
10 1
Output
2
Note
In the first sample Sasha puts electrons at all points, all particles eventually fall at a single point (1, 0).
In the second sample Sasha puts an electron at point (1, 10), and a proton at point (10, 1). The result is a set of two points (1, 0) and (0, 1), which has a diameter of <image>.
Submitted Solution:
```
n= int(input(""))
X= []
Y= []
for i in range(n):
a= input("").split(" ")
x= int(a[0])
y= int(a[1])
if x>y:
x= 0
else:
y= 0
X.append(x)
Y.append(y)
mx= max(X)
my= max(Y)
if mx==0:
print(my-min(Y))
elif my==0:
print(mx-min(X))
else:
print(mx**2+my**2)
``` | instruction | 0 | 75,502 | 3 | 151,004 |
No | output | 1 | 75,502 | 3 | 151,005 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
Programmer Sasha is a student at MIPT (Moscow Institute of Physics and Technology) and he needs to make a laboratory work to pass his finals.
A laboratory unit is a plane with standard coordinate axes marked on it. Physicists from Moscow Institute of Physics and Technology charged the axes by large electric charges: axis X is positive and axis Y is negative.
Experienced laboratory worker marked n points with integer coordinates (xi, yi) on the plane and stopped the time. Sasha should use "atomic tweezers" to place elementary particles in these points. He has an unlimited number of electrons (negatively charged elementary particles) and protons (positively charged elementary particles). He can put either an electron or a proton at each marked point. As soon as all marked points are filled with particles, laboratory worker will turn on the time again and the particles will come in motion and after some time they will stabilize in equilibrium. The objective of the laboratory work is to arrange the particles in such a way, that the diameter of the resulting state (the maximum distance between the pairs of points of the set) is as small as possible.
Since Sasha is a programmer, he naively thinks that all the particles will simply "fall" into their projections on the corresponding axes: electrons will fall on axis X, while protons will fall on axis Y. As we are programmers too, we will consider the same model as Sasha. That is, a particle gets from point (x, y) to point (x, 0) if it is an electron and to point (0, y) if it is a proton.
As the laboratory has high background radiation and Sasha takes care of his laptop, he did not take it with him, and now he can't write a program that computes the minimum possible diameter of the resulting set. Therefore, you will have to do it for him.
Print a square of the minimum possible diameter of the set.
Input
The first line of the input contains a single integer n (1 ≤ n ≤ 100 000) — the number of points marked on the plane.
Each of the next n lines contains two integers xi and yi ( - 108 ≤ xi, yi ≤ 108) — the coordinates of the i-th point. It is guaranteed that no two points coincide.
Output
Print a single integer — the square of the minimum possible diameter of the set.
Examples
Input
3
1 10
1 20
1 30
Output
0
Input
2
1 10
10 1
Output
2
Note
In the first sample Sasha puts electrons at all points, all particles eventually fall at a single point (1, 0).
In the second sample Sasha puts an electron at point (1, 10), and a proton at point (10, 1). The result is a set of two points (1, 0) and (0, 1), which has a diameter of <image>.
Submitted Solution:
```
n= int(input(""))
X= []
Y= []
for i in range(n):
a= input("").split(" ")
x= int(a[0])
y= int(a[1])
if x>y:
x= 0
else:
y= 0
X.append(x)
Y.append(y)
mx= max(X)
my= max(Y)
if mx==0:
print(my-min(Y))
elif my==0:
print(mx-min(X))
else:
print(mx+my)
``` | instruction | 0 | 75,503 | 3 | 151,006 |
No | output | 1 | 75,503 | 3 | 151,007 |
Provide tags and a correct Python 3 solution for this coding contest problem.
Cowboy Beblop is a funny little boy who likes sitting at his computer. He somehow obtained two elastic hoops in the shape of 2D polygons, which are not necessarily convex. Since there's no gravity on his spaceship, the hoops are standing still in the air. Since the hoops are very elastic, Cowboy Beblop can stretch, rotate, translate or shorten their edges as much as he wants.
For both hoops, you are given the number of their vertices, as well as the position of each vertex, defined by the X , Y and Z coordinates. The vertices are given in the order they're connected: the 1st vertex is connected to the 2nd, which is connected to the 3rd, etc., and the last vertex is connected to the first one. Two hoops are connected if it's impossible to pull them to infinity in different directions by manipulating their edges, without having their edges or vertices intersect at any point – just like when two links of a chain are connected. The polygons' edges do not intersect or overlap.
To make things easier, we say that two polygons are well-connected, if the edges of one polygon cross the area of the other polygon in two different directions (from the upper and lower sides of the plane defined by that polygon) a different number of times.
Cowboy Beblop is fascinated with the hoops he has obtained and he would like to know whether they are well-connected or not. Since he’s busy playing with his dog, Zwei, he’d like you to figure it out for him. He promised you some sweets if you help him!
Input
The first line of input contains an integer n (3 ≤ n ≤ 100 000), which denotes the number of edges of the first polygon. The next N lines each contain the integers x, y and z ( - 1 000 000 ≤ x, y, z ≤ 1 000 000) — coordinates of the vertices, in the manner mentioned above. The next line contains an integer m (3 ≤ m ≤ 100 000) , denoting the number of edges of the second polygon, followed by m lines containing the coordinates of the second polygon’s vertices.
It is guaranteed that both polygons are simple (no self-intersections), and in general that the obtained polygonal lines do not intersect each other. Also, you can assume that no 3 consecutive points of a polygon lie on the same line.
Output
Your output should contain only one line, with the words "YES" or "NO", depending on whether the two given polygons are well-connected.
Example
Input
4
0 0 0
2 0 0
2 2 0
0 2 0
4
1 1 -1
1 1 1
1 3 1
1 3 -1
Output
YES
Note
On the picture below, the two polygons are well-connected, as the edges of the vertical polygon cross the area of the horizontal one exactly once in one direction (for example, from above to below), and zero times in the other (in this case, from below to above). Note that the polygons do not have to be parallel to any of the xy-,xz-,yz- planes in general. <image> | instruction | 0 | 75,537 | 3 | 151,074 |
Tags: geometry
Correct Solution:
```
"""Cowboy Beblop at his computer, problem 717I from https://codeforces.com/problemset/problem/717/I"""
# from fractions import Fraction
# def convert_to_fractions(poly):
# """convert polygon vertex to fractional type"""
# poly_frac = []
# for x, y, z in poly:
# vertex = (Fraction(x),
# Fraction(y),
# Fraction(z))
# poly_frac.append(vertex)
# return poly_frac
def convert_to_float(poly):
"""convert polygon vertex to float type"""
poly_float = []
for x, y, z in poly:
vertex = (float(x),
float(y),
float(z))
poly_float.append(vertex)
return poly_float
def cross_product(a, b):
"""3-vector product"""
return (a[1] * b[2] - a[2] * b[1],
a[2] * b[0] - a[0] * b[2],
a[0] * b[1] - a[1] * b[0])
def dot_product(a, b):
"""scalar product of 3-vectors"""
return a[0] * b[0] + a[1] * b[1] + a[2] * b[2]
def vect_diff(a, b):
"""vector difference"""
return a[0] - b[0], a[1] - b[1], a[2] - b[2]
def poly_normal(poly):
"""return normal vector for first three vertex"""
assert len(poly) >= 3
x, y, z = poly[:3]
u = vect_diff(y, x)
v = vect_diff(z, y)
return cross_product(u, v)
def intersect_list(poly, plain_norm, plain_point, proj_dir):
"""list of intersection points
find points where the edges enter or leave upper half-space over the plain
:return list of points projection on proj_dir
"""
# vertex projection
u = [dot_product(vert, proj_dir) for vert in poly]
# plain anchor
vr = dot_product(plain_point, plain_norm)
# polygon vertex
v = [dot_product(vert, plain_norm) for vert in poly]
u_list = []
for i in range(len(poly)):
if (v[i-1] > vr) != (v[i] > vr):
ur = ((vr - v[i-1]) * u[i] + (v[i] - vr) * u[i-1]) / (v[i] - v[i-1])
u_list.append(ur)
return u_list
def points_to_str(a_points, b_points):
"""string representing the order of points 'a' and 'b'"""
a_pairs = [('a', val) for val in a_points]
b_pairs = [('b', val) for val in b_points]
pairs = sorted(a_pairs + b_pairs, key=lambda pair: pair[1])
letters = [ch for ch, _ in pairs]
return ''.join(letters)
def recognize_str(s):
"""return True if string s belong to the grammar
The context-free grammar is given
S -> SS
S -> a S a
S -> b S b
S -> e
The recognising automaton is implemented
"""
toggle = {'a':'b', 'b':'a'}
cross_num = 0
top = None
for ch in s:
if not cross_num:
cross_num = 1
top = ch
continue
if ch == top:
cross_num -= 1
else:
cross_num += 1
if cross_num:
top = toggle[top]
else:
top = None
return not cross_num
def is_well_connected(a, b):
"""Two planar polygons are bind together in 3D
Arguments:
a_poly,
b_poly -- lists of vertex triples
"""
a = convert_to_float(a)
b = convert_to_float(b)
a_norm = poly_normal(a)
b_norm = poly_normal(b)
common_dir = cross_product(a_norm, b_norm)
if not any(common_dir):
return False
a_list = intersect_list(a, b_norm, b[0], common_dir)
b_list = intersect_list(b, a_norm, a[0], common_dir)
char_str = points_to_str(a_list, b_list)
return not recognize_str(char_str)
def run_from_console():
a_len, = [int(num) for num in input().split()]
a = []
for _ in range(a_len):
vertex = tuple(int(num) for num in input().split())
a.append(vertex)
b_len, = [int(num) for num in input().split()]
b = []
for _ in range(b_len):
vertex = tuple(int(num) for num in input().split())
b.append(vertex)
if is_well_connected(a, b):
print('YES')
else:
print('NO')
if __name__ == '__main__':
run_from_console()
``` | output | 1 | 75,537 | 3 | 151,075 |
Provide tags and a correct Python 3 solution for this coding contest problem.
Cowboy Beblop is a funny little boy who likes sitting at his computer. He somehow obtained two elastic hoops in the shape of 2D polygons, which are not necessarily convex. Since there's no gravity on his spaceship, the hoops are standing still in the air. Since the hoops are very elastic, Cowboy Beblop can stretch, rotate, translate or shorten their edges as much as he wants.
For both hoops, you are given the number of their vertices, as well as the position of each vertex, defined by the X , Y and Z coordinates. The vertices are given in the order they're connected: the 1st vertex is connected to the 2nd, which is connected to the 3rd, etc., and the last vertex is connected to the first one. Two hoops are connected if it's impossible to pull them to infinity in different directions by manipulating their edges, without having their edges or vertices intersect at any point – just like when two links of a chain are connected. The polygons' edges do not intersect or overlap.
To make things easier, we say that two polygons are well-connected, if the edges of one polygon cross the area of the other polygon in two different directions (from the upper and lower sides of the plane defined by that polygon) a different number of times.
Cowboy Beblop is fascinated with the hoops he has obtained and he would like to know whether they are well-connected or not. Since he’s busy playing with his dog, Zwei, he’d like you to figure it out for him. He promised you some sweets if you help him!
Input
The first line of input contains an integer n (3 ≤ n ≤ 100 000), which denotes the number of edges of the first polygon. The next N lines each contain the integers x, y and z ( - 1 000 000 ≤ x, y, z ≤ 1 000 000) — coordinates of the vertices, in the manner mentioned above. The next line contains an integer m (3 ≤ m ≤ 100 000) , denoting the number of edges of the second polygon, followed by m lines containing the coordinates of the second polygon’s vertices.
It is guaranteed that both polygons are simple (no self-intersections), and in general that the obtained polygonal lines do not intersect each other. Also, you can assume that no 3 consecutive points of a polygon lie on the same line.
Output
Your output should contain only one line, with the words "YES" or "NO", depending on whether the two given polygons are well-connected.
Example
Input
4
0 0 0
2 0 0
2 2 0
0 2 0
4
1 1 -1
1 1 1
1 3 1
1 3 -1
Output
YES
Note
On the picture below, the two polygons are well-connected, as the edges of the vertical polygon cross the area of the horizontal one exactly once in one direction (for example, from above to below), and zero times in the other (in this case, from below to above). Note that the polygons do not have to be parallel to any of the xy-,xz-,yz- planes in general. <image> | instruction | 0 | 75,538 | 3 | 151,076 |
Tags: geometry
Correct Solution:
```
def convert_to_float(poly):
"""convert polygon vertex to float type"""
poly_float = []
for x, y, z in poly:
vertex = (float(x),
float(y),
float(z))
poly_float.append(vertex)
return poly_float
def cross_product(a, b):
"""3-vector product"""
return (a[1] * b[2] - a[2] * b[1],
a[2] * b[0] - a[0] * b[2],
a[0] * b[1] - a[1] * b[0])
def dot_product(a, b):
"""scalar product of 3-vectors"""
return a[0] * b[0] + a[1] * b[1] + a[2] * b[2]
def vect_diff(a, b):
"""vector difference"""
return a[0] - b[0], a[1] - b[1], a[2] - b[2]
def poly_normal(poly):
"""return normal vector for first three vertex"""
assert len(poly) >= 3
x, y, z = poly[:3]
u = vect_diff(y, x)
v = vect_diff(z, y)
return cross_product(u, v)
def intersect_list(poly, plain_norm, plain_point, proj_dir):
"""list of intersection points
find points where the edges enter or leave upper half-space over the plain
:return list of points projection on proj_dir
"""
u = [dot_product(vert, proj_dir) for vert in poly]
vr = dot_product(plain_point, plain_norm)
v = [dot_product(vert, plain_norm) for vert in poly]
u_list = []
for i in range(len(poly)):
if (v[i-1] > vr) != (v[i] > vr):
ur = ((vr - v[i-1]) * u[i] + (v[i] - vr) * u[i-1]) / (v[i] - v[i-1])
u_list.append(ur)
return u_list
def points_to_str(a_points, b_points):
"""string representing the order of points 'a' and 'b'"""
a_pairs = [('a', val) for val in a_points]
b_pairs = [('b', val) for val in b_points]
pairs = sorted(a_pairs + b_pairs, key=lambda pair: pair[1])
letters = [ch for ch, _ in pairs]
return ''.join(letters)
def recognize_str(s):
"""return True if string s belong to the grammar
The context-free grammar is given
S -> SS
S -> a S a
S -> b S b
S -> e
The recognising automaton is implemented
"""
toggle = {'a':'b', 'b':'a'}
cross_num = 0
top = None
for ch in s:
if not cross_num:
cross_num = 1
top = ch
continue
if ch == top:
cross_num -= 1
else:
cross_num += 1
if cross_num:
top = toggle[top]
else:
top = None
return not cross_num
def is_well_connected(a, b):
"""Two planar polygons are bind together in 3D
Arguments:
a_poly,
b_poly -- lists of vertex triples
"""
a = convert_to_float(a)
b = convert_to_float(b)
a_norm = poly_normal(a)
b_norm = poly_normal(b)
common_dir = cross_product(a_norm, b_norm)
if not any(common_dir):
return False
a_list = intersect_list(a, b_norm, b[0], common_dir)
b_list = intersect_list(b, a_norm, a[0], common_dir)
char_str = points_to_str(a_list, b_list)
return not recognize_str(char_str)
def run_from_console():
a_len, = [int(num) for num in input().split()]
a = []
for _ in range(a_len):
vertex = tuple(int(num) for num in input().split())
a.append(vertex)
b_len, = [int(num) for num in input().split()]
b = []
for _ in range(b_len):
vertex = tuple(int(num) for num in input().split())
b.append(vertex)
if is_well_connected(a, b):
print('YES')
else:
print('NO')
if __name__ == '__main__':
run_from_console()
``` | output | 1 | 75,538 | 3 | 151,077 |
Provide tags and a correct Python 3 solution for this coding contest problem.
Cowboy Beblop is a funny little boy who likes sitting at his computer. He somehow obtained two elastic hoops in the shape of 2D polygons, which are not necessarily convex. Since there's no gravity on his spaceship, the hoops are standing still in the air. Since the hoops are very elastic, Cowboy Beblop can stretch, rotate, translate or shorten their edges as much as he wants.
For both hoops, you are given the number of their vertices, as well as the position of each vertex, defined by the X , Y and Z coordinates. The vertices are given in the order they're connected: the 1st vertex is connected to the 2nd, which is connected to the 3rd, etc., and the last vertex is connected to the first one. Two hoops are connected if it's impossible to pull them to infinity in different directions by manipulating their edges, without having their edges or vertices intersect at any point – just like when two links of a chain are connected. The polygons' edges do not intersect or overlap.
To make things easier, we say that two polygons are well-connected, if the edges of one polygon cross the area of the other polygon in two different directions (from the upper and lower sides of the plane defined by that polygon) a different number of times.
Cowboy Beblop is fascinated with the hoops he has obtained and he would like to know whether they are well-connected or not. Since he’s busy playing with his dog, Zwei, he’d like you to figure it out for him. He promised you some sweets if you help him!
Input
The first line of input contains an integer n (3 ≤ n ≤ 100 000), which denotes the number of edges of the first polygon. The next N lines each contain the integers x, y and z ( - 1 000 000 ≤ x, y, z ≤ 1 000 000) — coordinates of the vertices, in the manner mentioned above. The next line contains an integer m (3 ≤ m ≤ 100 000) , denoting the number of edges of the second polygon, followed by m lines containing the coordinates of the second polygon’s vertices.
It is guaranteed that both polygons are simple (no self-intersections), and in general that the obtained polygonal lines do not intersect each other. Also, you can assume that no 3 consecutive points of a polygon lie on the same line.
Output
Your output should contain only one line, with the words "YES" or "NO", depending on whether the two given polygons are well-connected.
Example
Input
4
0 0 0
2 0 0
2 2 0
0 2 0
4
1 1 -1
1 1 1
1 3 1
1 3 -1
Output
YES
Note
On the picture below, the two polygons are well-connected, as the edges of the vertical polygon cross the area of the horizontal one exactly once in one direction (for example, from above to below), and zero times in the other (in this case, from below to above). Note that the polygons do not have to be parallel to any of the xy-,xz-,yz- planes in general. <image> | instruction | 0 | 75,539 | 3 | 151,078 |
Tags: geometry
Correct Solution:
```
def convert_to_float(poly):
"""convert polygon vertex to float type"""
poly_float = []
for x, y, z in poly:
vertex = (float(x),
float(y),
float(z))
poly_float.append(vertex)
return poly_float
def cross_product(a, b):
"""3-vector product"""
return (a[1] * b[2] - a[2] * b[1],
a[2] * b[0] - a[0] * b[2],
a[0] * b[1] - a[1] * b[0])
def dot_product(a, b):
"""scalar product of 3-vectors"""
return a[0] * b[0] + a[1] * b[1] + a[2] * b[2]
def vect_diff(a, b):
"""vector difference"""
return a[0] - b[0], a[1] - b[1], a[2] - b[2]
def poly_normal(poly):
"""return normal vector for first three vertex"""
assert len(poly) >= 3
x, y, z = poly[:3]
u = vect_diff(y, x)
v = vect_diff(z, y)
return cross_product(u, v)
def intersect_list(poly, plain_norm, plain_point, proj_dir):
"""list of intersection points
find points where the edges enter or leave upper half-space over the plain
:return list of points projection on proj_dir
"""
# vertex projection
u = [dot_product(vert, proj_dir) for vert in poly]
# plain anchor
vr = dot_product(plain_point, plain_norm)
# polygon vertex
v = [dot_product(vert, plain_norm) for vert in poly]
u_list = []
for i in range(len(poly)):
if (v[i-1] > vr) != (v[i] > vr):
ur = ((vr - v[i-1]) * u[i] + (v[i] - vr) * u[i-1]) / (v[i] - v[i-1])
u_list.append(ur)
return u_list
def points_to_str(a_points, b_points):
"""string representing the order of points 'a' and 'b'"""
a_pairs = [('a', val) for val in a_points]
b_pairs = [('b', val) for val in b_points]
pairs = sorted(a_pairs + b_pairs, key=lambda pair: pair[1])
letters = [ch for ch, _ in pairs]
return ''.join(letters)
def recognize_str(s):
"""return True if string s belong to the grammar
The context-free grammar is given
S -> SS
S -> a S a
S -> b S b
S -> e
The recognising automaton is implemented
"""
toggle = {'a':'b', 'b':'a'}
cross_num = 0
top = None
for ch in s:
if not cross_num:
cross_num = 1
top = ch
continue
if ch == top:
cross_num -= 1
else:
cross_num += 1
if cross_num:
top = toggle[top]
else:
top = None
return not cross_num
def is_well_connected(a, b):
"""Two planar polygons are bind together in 3D
Arguments:
a_poly,
b_poly -- lists of vertex triples
"""
a = convert_to_float(a)
b = convert_to_float(b)
a_norm = poly_normal(a)
b_norm = poly_normal(b)
common_dir = cross_product(a_norm, b_norm)
if not any(common_dir):
return False
a_list = intersect_list(a, b_norm, b[0], common_dir)
b_list = intersect_list(b, a_norm, a[0], common_dir)
char_str = points_to_str(a_list, b_list)
return not recognize_str(char_str)
def run_from_console():
a_len, = [int(num) for num in input().split()]
a = []
for _ in range(a_len):
vertex = tuple(int(num) for num in input().split())
a.append(vertex)
b_len, = [int(num) for num in input().split()]
b = []
for _ in range(b_len):
vertex = tuple(int(num) for num in input().split())
b.append(vertex)
if is_well_connected(a, b):
print('YES')
else:
print('NO')
if __name__ == '__main__':
run_from_console()
``` | output | 1 | 75,539 | 3 | 151,079 |
Provide tags and a correct Python 3 solution for this coding contest problem.
Cowboy Beblop is a funny little boy who likes sitting at his computer. He somehow obtained two elastic hoops in the shape of 2D polygons, which are not necessarily convex. Since there's no gravity on his spaceship, the hoops are standing still in the air. Since the hoops are very elastic, Cowboy Beblop can stretch, rotate, translate or shorten their edges as much as he wants.
For both hoops, you are given the number of their vertices, as well as the position of each vertex, defined by the X , Y and Z coordinates. The vertices are given in the order they're connected: the 1st vertex is connected to the 2nd, which is connected to the 3rd, etc., and the last vertex is connected to the first one. Two hoops are connected if it's impossible to pull them to infinity in different directions by manipulating their edges, without having their edges or vertices intersect at any point – just like when two links of a chain are connected. The polygons' edges do not intersect or overlap.
To make things easier, we say that two polygons are well-connected, if the edges of one polygon cross the area of the other polygon in two different directions (from the upper and lower sides of the plane defined by that polygon) a different number of times.
Cowboy Beblop is fascinated with the hoops he has obtained and he would like to know whether they are well-connected or not. Since he’s busy playing with his dog, Zwei, he’d like you to figure it out for him. He promised you some sweets if you help him!
Input
The first line of input contains an integer n (3 ≤ n ≤ 100 000), which denotes the number of edges of the first polygon. The next N lines each contain the integers x, y and z ( - 1 000 000 ≤ x, y, z ≤ 1 000 000) — coordinates of the vertices, in the manner mentioned above. The next line contains an integer m (3 ≤ m ≤ 100 000) , denoting the number of edges of the second polygon, followed by m lines containing the coordinates of the second polygon’s vertices.
It is guaranteed that both polygons are simple (no self-intersections), and in general that the obtained polygonal lines do not intersect each other. Also, you can assume that no 3 consecutive points of a polygon lie on the same line.
Output
Your output should contain only one line, with the words "YES" or "NO", depending on whether the two given polygons are well-connected.
Example
Input
4
0 0 0
2 0 0
2 2 0
0 2 0
4
1 1 -1
1 1 1
1 3 1
1 3 -1
Output
YES
Note
On the picture below, the two polygons are well-connected, as the edges of the vertical polygon cross the area of the horizontal one exactly once in one direction (for example, from above to below), and zero times in the other (in this case, from below to above). Note that the polygons do not have to be parallel to any of the xy-,xz-,yz- planes in general. <image> | instruction | 0 | 75,540 | 3 | 151,080 |
Tags: geometry
Correct Solution:
```
from math import gcd, sqrt
from functools import reduce
import sys
input = sys.stdin.readline
EPS = 0.0000000001
def inp():
return(int(input()))
def inlt():
return(list(map(int,input().split())))
def GCD(args):
return reduce(gcd, args)
def plane_value(plane, point):
A, B, C, D = plane
x, y, z = point
return A*x + B*y + C*z + D
def plane(p1, p2, p3):
x1, y1, z1 = p1
x2, y2, z2 = p2
x3, y3, z3 = p3
a1, b1, c1 = x2 - x1, y2 - y1, z2 - z1
a2, b2, c2 = x3 - x1, y3 - y1, z3 - z1
a, b, c = b1 * c2 - b2 * c1, a2 * c1 - a1 * c2, a1 * b2 - b1 * a2
d = (- a * x1 - b * y1 - c * z1)
g = GCD([a,b,c,d])
return a//g, b//g, c//g, d//g
def cross(a, b):
return (a[1]*b[2]-a[2]*b[1], a[2]*b[0]-a[0]*b[2], a[0]*b[1]-a[1]*b[0])
def intersection_of_two_planes(p1, p2):
A1, B1, C1, D1 = p1
A2, B2, C2, D2 = p2
#
crossprod = cross([A1,B1,C1],[A2,B2,C2])
if (A1*B2-A2*B1) != 0:
x = ((B1*D2-B2*D1)/(A1*B2-A2*B1), crossprod[0])
y = ((A2*D1-A1*D2)/(A1*B2-A2*B1), crossprod[1])
z = (0,crossprod[2])
elif (B1*C2-B2*C1) != 0:
x = (0,crossprod[0])
y = ((C1*D2-C2*D1)/(B1*C2-B2*C1), crossprod[1])
z = ((B2*D1-B1*D2)/(B1*C2-B2*C1), crossprod[2])
elif (A1*C2-A2*C1) != 0:
x = ((C1*D2-C2*D1)/(A1*C2-A2*C1), crossprod[0])
y = (0,crossprod[1])
z = ((A2*D1-A1*D2)/(A1*C2-A2*C1), crossprod[2])
else:
return None
return x, y, z
def line_parametric(p1, p2):
x1, y1, z1 = p1
x2, y2, z2 = p2
return (x2,x1-x2), (y2,y1-y2), (z2,z1-z2)
def solve_2_by_2(row1, row2):
a1, b1, c1 = row1
a2, b2, c2 = row2
if a1*b2-b1*a2:
return (c1*b2-b1*c2)/(a1*b2-b1*a2), (a1*c2-c1*a2)/(a1*b2-b1*a2)
else:
return None
def sgn(x):
return 1 if x>0 else 0 if x==0 else -1
def lines_intersection_point(i1, i2):
x1, y1, z1 = i1
x2, y2, z2 = i2
try:
t1, t2 = solve_2_by_2([x1[1], -x2[1], x2[0]-x1[0]], [y1[1], -y2[1], y2[0]-y1[0]])
if abs(t1*z1[1] - t2*z2[1] - z2[0] + z1[0]) < EPS:
return (x1[0]+t1*x1[1], y1[0]+t1*y1[1], z1[0]+t1*z1[1]), t2
else:
return None
except:
try:
t1, t2 = solve_2_by_2([x1[1], -x2[1], x2[0]-x1[0]], [z1[1], -z2[1], z2[0]-z1[0]])
if abs(t1*y1[1] - t2*y2[1] - y2[0] + y1[0]) < EPS:
return (x1[0]+t1*x1[1], y1[0]+t1*y1[1], z1[0]+t1*z1[1]), t2
else:
return None
except:
try:
t1, t2 = solve_2_by_2([y1[1], -y2[1], y2[0]-y1[0]], [z1[1], -z2[1], z2[0]-z1[0]])
if abs(t1*x1[1] - t2*x2[1] - x2[0] + x1[0]) < EPS:
return (x1[0]+t1*x1[1], y1[0]+t1*y1[1], z1[0]+t1*z1[1]), t2
else:
return None
except:
return None
def foo(points):
down_cnt, up_cnt = 0, 0
first = points[0]
other = 1-first
down = True
intrusion = True
for p in points[1:]:
if p==first:
intrusion = not intrusion
else:
if intrusion:
if down:
down_cnt+=1
else:
up_cnt+=1
down = not down
return down_cnt==up_cnt
def populate(plane, poly, tag):
res = []
prev = plane_value(plane,poly[-1])
prev_serious = plane_value(plane,poly[-2]) if not prev else prev
p_prev = poly[-1]
for i in range(len(poly)+1):
p = poly[i%len(poly)]
curr = plane_value(plane,p)
if sgn(curr) == -sgn(prev_serious):
intersector = line_parametric(p_prev,p)
point, t = lines_intersection_point(intersector,intersectee)
res.append((t,tag))
prev_serious = curr
if sgn(curr):
prev_serious = curr
prev, p_prev = curr, p
return res
x_poly, y_poly = [], []
for _ in range(inp()):
x_poly.append(inlt())
for _ in range(inp()):
y_poly.append(inlt())
x_plane = plane(*x_poly[:3])
y_plane = plane(*y_poly[:3])
intersectee = intersection_of_two_planes(x_plane,y_plane)
if intersectee:
points = sorted(set(populate(y_plane,x_poly,0) + populate(x_plane,y_poly,1)))
points = [i[1] for i in points]
print('NO' if foo(points) else 'YES')
else:
print('NO')
``` | output | 1 | 75,540 | 3 | 151,081 |
Provide tags and a correct Python 3 solution for this coding contest problem.
Cowboy Beblop is a funny little boy who likes sitting at his computer. He somehow obtained two elastic hoops in the shape of 2D polygons, which are not necessarily convex. Since there's no gravity on his spaceship, the hoops are standing still in the air. Since the hoops are very elastic, Cowboy Beblop can stretch, rotate, translate or shorten their edges as much as he wants.
For both hoops, you are given the number of their vertices, as well as the position of each vertex, defined by the X , Y and Z coordinates. The vertices are given in the order they're connected: the 1st vertex is connected to the 2nd, which is connected to the 3rd, etc., and the last vertex is connected to the first one. Two hoops are connected if it's impossible to pull them to infinity in different directions by manipulating their edges, without having their edges or vertices intersect at any point – just like when two links of a chain are connected. The polygons' edges do not intersect or overlap.
To make things easier, we say that two polygons are well-connected, if the edges of one polygon cross the area of the other polygon in two different directions (from the upper and lower sides of the plane defined by that polygon) a different number of times.
Cowboy Beblop is fascinated with the hoops he has obtained and he would like to know whether they are well-connected or not. Since he’s busy playing with his dog, Zwei, he’d like you to figure it out for him. He promised you some sweets if you help him!
Input
The first line of input contains an integer n (3 ≤ n ≤ 100 000), which denotes the number of edges of the first polygon. The next N lines each contain the integers x, y and z ( - 1 000 000 ≤ x, y, z ≤ 1 000 000) — coordinates of the vertices, in the manner mentioned above. The next line contains an integer m (3 ≤ m ≤ 100 000) , denoting the number of edges of the second polygon, followed by m lines containing the coordinates of the second polygon’s vertices.
It is guaranteed that both polygons are simple (no self-intersections), and in general that the obtained polygonal lines do not intersect each other. Also, you can assume that no 3 consecutive points of a polygon lie on the same line.
Output
Your output should contain only one line, with the words "YES" or "NO", depending on whether the two given polygons are well-connected.
Example
Input
4
0 0 0
2 0 0
2 2 0
0 2 0
4
1 1 -1
1 1 1
1 3 1
1 3 -1
Output
YES
Note
On the picture below, the two polygons are well-connected, as the edges of the vertical polygon cross the area of the horizontal one exactly once in one direction (for example, from above to below), and zero times in the other (in this case, from below to above). Note that the polygons do not have to be parallel to any of the xy-,xz-,yz- planes in general. <image> | instruction | 0 | 75,541 | 3 | 151,082 |
Tags: geometry
Correct Solution:
```
from math import gcd, sqrt
from functools import reduce
import sys
input = sys.stdin.readline
EPS = 0.000000001
def inp():
return(int(input()))
def inlt():
return(list(map(int,input().split())))
def GCD(args):
return reduce(gcd, args)
def plane_value(plane, point):
A, B, C, D = plane
x, y, z = point
return A*x + B*y + C*z + D
def plane(p1, p2, p3):
x1, y1, z1 = p1
x2, y2, z2 = p2
x3, y3, z3 = p3
a1, b1, c1 = x2 - x1, y2 - y1, z2 - z1
a2, b2, c2 = x3 - x1, y3 - y1, z3 - z1
a, b, c = b1 * c2 - b2 * c1, a2 * c1 - a1 * c2, a1 * b2 - b1 * a2
d = (- a * x1 - b * y1 - c * z1)
g = GCD([a,b,c,d])
return a//g, b//g, c//g, d//g
def cross(a, b):
return (a[1]*b[2]-a[2]*b[1], a[2]*b[0]-a[0]*b[2], a[0]*b[1]-a[1]*b[0])
def intersection_of_two_planes(p1, p2):
A1, B1, C1, D1 = p1
A2, B2, C2, D2 = p2
crossprod = cross([A1,B1,C1],[A2,B2,C2])
if (A1*B2-A2*B1) != 0:
x = ((B1*D2-B2*D1)/(A1*B2-A2*B1), crossprod[0])
y = ((A2*D1-A1*D2)/(A1*B2-A2*B1), crossprod[1])
z = (0,crossprod[2])
elif (B1*C2-B2*C1) != 0:
x = (0,crossprod[0])
y = ((C1*D2-C2*D1)/(B1*C2-B2*C1), crossprod[1])
z = ((B2*D1-B1*D2)/(B1*C2-B2*C1), crossprod[2])
elif (A1*C2-A2*C1) != 0:
x = ((C1*D2-C2*D1)/(A1*C2-A2*C1), crossprod[0])
y = (0,crossprod[1])
z = ((A2*D1-A1*D2)/(A1*C2-A2*C1), crossprod[2])
else:
return None
return x, y, z
def line_parametric(p1, p2):
x1, y1, z1 = p1
x2, y2, z2 = p2
return (x2,x1-x2), (y2,y1-y2), (z2,z1-z2)
def solve_2_by_2(row1, row2):
a1, b1, c1 = row1
a2, b2, c2 = row2
if a1*b2-b1*a2:
return (c1*b2-b1*c2)/(a1*b2-b1*a2), (a1*c2-c1*a2)/(a1*b2-b1*a2)
else:
return None
def sgn(x):
return 1 if x>0 else 0 if x==0 else -1
def lines_intersection_point(i1, i2):
x1, y1, z1 = i1
x2, y2, z2 = i2
try:
t1, t2 = solve_2_by_2([x1[1], -x2[1], x2[0]-x1[0]], [y1[1], -y2[1], y2[0]-y1[0]])
if abs(t1*z1[1] - t2*z2[1] - z2[0] + z1[0]) < EPS:
return (x1[0]+t1*x1[1], y1[0]+t1*y1[1], z1[0]+t1*z1[1]), t2
else:
return None
except:
try:
t1, t2 = solve_2_by_2([x1[1], -x2[1], x2[0]-x1[0]], [z1[1], -z2[1], z2[0]-z1[0]])
if abs(t1*y1[1] - t2*y2[1] - y2[0] + y1[0]) < EPS:
return (x1[0]+t1*x1[1], y1[0]+t1*y1[1], z1[0]+t1*z1[1]), t2
else:
return None
except:
try:
t1, t2 = solve_2_by_2([y1[1], -y2[1], y2[0]-y1[0]], [z1[1], -z2[1], z2[0]-z1[0]])
if abs(t1*x1[1] - t2*x2[1] - x2[0] + x1[0]) < EPS:
return (x1[0]+t1*x1[1], y1[0]+t1*y1[1], z1[0]+t1*z1[1]), t2
else:
return None
except:
return None
def foo(points):
down_cnt, up_cnt = 0, 0
first = points[0]
other = 1-first
down = True
intrusion = True
for p in points[1:]:
if p==first:
intrusion = not intrusion
else:
if intrusion:
if down:
down_cnt+=1
else:
up_cnt+=1
down = not down
return down_cnt==up_cnt
def populate(plane, poly, tag):
res = []
prev = plane_value(plane,poly[-1])
prev_serious = plane_value(plane,poly[-2]) if not prev else prev
p_prev = poly[-1]
for i in range(len(poly)+1):
p = poly[i%len(poly)]
curr = plane_value(plane,p)
if sgn(curr) == -sgn(prev_serious):
intersector = line_parametric(p_prev,p)
point, t = lines_intersection_point(intersector,intersectee)
res.append((t,tag))
prev_serious = curr
if sgn(curr):
prev_serious = curr
prev, p_prev = curr, p
return res
x_poly, y_poly = [], []
for _ in range(inp()):
x_poly.append(inlt())
for _ in range(inp()):
y_poly.append(inlt())
x_plane = plane(*x_poly[:3])
y_plane = plane(*y_poly[:3])
intersectee = intersection_of_two_planes(x_plane,y_plane)
if intersectee:
points = sorted(set(populate(y_plane,x_poly,0) + populate(x_plane,y_poly,1)))
points = [i[1] for i in points]
print('NO' if foo(points) else 'YES')
else:
print('NO')
``` | output | 1 | 75,541 | 3 | 151,083 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
Cowboy Beblop is a funny little boy who likes sitting at his computer. He somehow obtained two elastic hoops in the shape of 2D polygons, which are not necessarily convex. Since there's no gravity on his spaceship, the hoops are standing still in the air. Since the hoops are very elastic, Cowboy Beblop can stretch, rotate, translate or shorten their edges as much as he wants.
For both hoops, you are given the number of their vertices, as well as the position of each vertex, defined by the X , Y and Z coordinates. The vertices are given in the order they're connected: the 1st vertex is connected to the 2nd, which is connected to the 3rd, etc., and the last vertex is connected to the first one. Two hoops are connected if it's impossible to pull them to infinity in different directions by manipulating their edges, without having their edges or vertices intersect at any point – just like when two links of a chain are connected. The polygons' edges do not intersect or overlap.
To make things easier, we say that two polygons are well-connected, if the edges of one polygon cross the area of the other polygon in two different directions (from the upper and lower sides of the plane defined by that polygon) a different number of times.
Cowboy Beblop is fascinated with the hoops he has obtained and he would like to know whether they are well-connected or not. Since he’s busy playing with his dog, Zwei, he’d like you to figure it out for him. He promised you some sweets if you help him!
Input
The first line of input contains an integer n (3 ≤ n ≤ 100 000), which denotes the number of edges of the first polygon. The next N lines each contain the integers x, y and z ( - 1 000 000 ≤ x, y, z ≤ 1 000 000) — coordinates of the vertices, in the manner mentioned above. The next line contains an integer m (3 ≤ m ≤ 100 000) , denoting the number of edges of the second polygon, followed by m lines containing the coordinates of the second polygon’s vertices.
It is guaranteed that both polygons are simple (no self-intersections), and in general that the obtained polygonal lines do not intersect each other. Also, you can assume that no 3 consecutive points of a polygon lie on the same line.
Output
Your output should contain only one line, with the words "YES" or "NO", depending on whether the two given polygons are well-connected.
Example
Input
4
0 0 0
2 0 0
2 2 0
0 2 0
4
1 1 -1
1 1 1
1 3 1
1 3 -1
Output
YES
Note
On the picture below, the two polygons are well-connected, as the edges of the vertical polygon cross the area of the horizontal one exactly once in one direction (for example, from above to below), and zero times in the other (in this case, from below to above). Note that the polygons do not have to be parallel to any of the xy-,xz-,yz- planes in general. <image>
Submitted Solution:
```
# import numpy as np
import sys
from math import gcd, sqrt
EPS = 0.0000000001
input = sys.stdin.readline
def inp():
return(int(input()))
def inlt():
return(list(map(int,input().split())))
def insr():
s = input()
return s
def invr():
return(list(map(int,input().split())))
def plane(p1, p2, p3):
x1, y1, z1 = p1
x2, y2, z2 = p2
x3, y3, z3 = p3
a1, b1, c1 = x2 - x1, y2 - y1, z2 - z1
a2, b2, c2 = x3 - x1, y3 - y1, z3 - z1
a, b, c = b1 * c2 - b2 * c1, a2 * c1 - a1 * c2, a1 * b2 - b1 * a2
d = (- a * x1 - b * y1 - c * z1)
return a, b, c, d
def intersection_of_two_planes(p1, p2):
A1, B1, C1, D1 = p1
A2, B2, C2, D2 = p2
if (A1*B2-A2*B1) != 0:
x = ((B1*D2-B2*D1,A1*B2-A2*B1), B1*C2-B2*C1)
y = ((A2*D1-A1*D2,A1*B2-A2*B1), A2*C1-A1*C2)
z = ((0,1),1)
elif (B1*C2-B2*C1) != 0:
x = ((0,1),1)
y = ((C1*D2-C2*D1,B1*C2-B2*C1), C1*A2-C2*A1)
z = ((B2*D1-B1*D2,B1*C2-B2*C1), B2*A1-B1*A2)
elif (A1*C2-A2*C1) != 0:
y = ((0,1),1)
x = ((C1*D2-C2*D1,A1*C2-A2*C1), C1*B2-C2*B1)
z = ((A2*D1-A1*D2,A1*C2-A2*C1), A2*B1-A1*B2)
else:
return None
return x, y, z
def line_parametric(p1, p2):
x1, y1, z1 = p1
x2, y2, z2 = p2
return ((x2,1),x1-x2), ((y2,1),y1-y2), ((z2,1),z1-z2)
def solve_2_by_2(a1,b1,c1p,c1q,a2,b2,c2p,c2q):
if a1*b2-b1*a2:
return (c1p*c2q*b2-b1*c2p*c1q,(a1*b2-b1*a2)*c1q*c2q), (a1*c2p*c1q-a2*c1p*c2q,(a1*b2-b1*a2)*c1q*c2q)
else:
return None, None
def intersection_of_two_lines(l1, l2):
res = []
px, py, pz = l1
qx, qy, qz = l2
try:
t1, t2 = solve_2_by_2(px[1],-qx[1],qx[0][0]*px[0][1]-px[0][0]*qx[0][1],qx[0][1]*px[0][1],py[1],-qy[1],qy[0][0]*py[0][1]-py[0][0]*qy[0][1],qy[0][1]*py[0][1])
p1, q1 = t1
p2, q2 = t2
if qz[0][1]*pz[0][1]*(p1*pz[1]*q2 - p2*qz[1]*q1) == q1*q2*(qz[0][0]*pz[0][1]-pz[0][0]*qz[0][1]):
return ((px[0][0]*q1+p1*px[1]*px[0][1],q1*px[0][1]), (py[0][0]*q1+p1*py[1]*py[0][1],q1*py[0][1]), (pz[0][0]*q1+p1*pz[1]*pz[0][1],q1*pz[0][1])), (p1,q1)
else:
return None, None
except:
pass
try:
t1, t2 = solve_2_by_2(px[1],-qx[1],qx[0][0]*px[0][1]-px[0][0]*qx[0][1],qx[0][1]*px[0][1],pz[1],-qz[1],qz[0][0]*pz[0][1]-pz[0][0]*qz[0][1],qz[0][1]*pz[0][1])
p1, q1 = t1
p2, q2 = t2
if qy[0][1]*py[0][1]*(p1*py[1]*q2 - p2*qy[1]*q1) == q1*q2*(qy[0][0]*py[0][1]-py[0][0]*qy[0][1]):
return ((px[0][0]*q1+p1*px[1]*px[0][1],q1*px[0][1]), (py[0][0]*q1+p1*py[1]*py[0][1],q1*py[0][1]), (pz[0][0]*q1+p1*pz[1]*pz[0][1],q1*pz[0][1])), (p1,q1)
else:
return None, None
except:
pass
try:
t1, t2 = solve_2_by_2(py[1],-qy[1],qy[0][0]*py[0][1]-py[0][0]*qy[0][1],qy[0][1]*py[0][1],pz[1],-qz[1],qz[0][0]*pz[0][1]-pz[0][0]*qz[0][1],qz[0][1]*pz[0][1])
p1, q1 = t1
p2, q2 = t2
if qx[0][1]*px[0][1]*(p1*px[1]*q2 - p2*qx[1]*q1) == q1*q2*(qx[0][0]*px[0][1]-px[0][0]*qx[0][1]):
return ((px[0][0]*q1+p1*px[1]*px[0][1],q1*px[0][1]), (py[0][0]*q1+p1*py[1]*py[0][1],q1*py[0][1]), (pz[0][0]*q1+p1*pz[1]*pz[0][1],q1*pz[0][1])), (p1,q1)
else:
return None, None
except:
pass
return None, None
def crop(points):
res = []
prev = None
cnt = 0
for p in points:
if p == prev:
cnt+=1
else:
if cnt & 1:
res.append(prev)
cnt = 1
prev = p
if cnt & 1:
res.append(prev)
return res
def distance(p1, p2):
x1, y1, z1 = p1
x2, y2, z2 = p2
if x2.__class__.__name__=='tuple':
x2p, x2q = x2
y2p, y2q = y2
z2p, z2q = z2
return sqrt((x1-x2p/x2q)**2+(y1-y2p/y2q)**2+(z1-z2p/z2q)**2)
return sqrt((x1-x2)**2+(y1-y2)**2+(z1-z2)**2)
def distinct(p1, intersection):
px1,py1,pz1 = p1
px3,py3,pz3 = intersection
px3p, px3q = px3
py3p, py3q = py3
pz3p, pz3q = pz3
return not (px1*px3q == px3p and py1*py3q == py3p and pz1*pz3q == pz3p)
# def in_line(p1, p2, intersection):
# px1,py1,pz1 = p1
# px2,py2,pz2 = p2
# px3,py3,pz3 = intersection
# px3p, px3q = px3
# py3p, py3q = py3
# pz3p, pz3q = pz3
# print(p1,p2,intersection)
# g = 1
# ortp1p2 = (px2-px1,py2-py1,pz2-pz1)
# print(px2-px1,py2-py1,pz2-pz1)
x_poly, y_poly = [], []
for _ in range(inp()):
x_poly.append(inlt())
for _ in range(inp()):
y_poly.append(inlt())
x_plane = plane(*x_poly[:3])
y_plane = plane(*y_poly[:3])
incidence = intersection_of_two_planes(x_plane,y_plane)
if incidence:
points = []
for i in range(len(x_poly)):
line = line_parametric(x_poly[i],x_poly[(i+1)%len(x_poly)])
intersection, t = intersection_of_two_lines(incidence,line)
# print(incidence, line)
if intersection:
p1 = x_poly[i]
p2 = x_poly[(i+1)%len(x_poly)]
# print(p1,p2,intersection)
# print(abs(distance(p1,intersection) + distance(p2,intersection) - distance(p1,p2)))
# in_line(p1,p2,intersection)
if abs(distance(p1,intersection) + distance(p2,intersection) - distance(p1,p2))<EPS:
if distinct(p1,intersection) and distinct(p2,intersection):
points.append((t,0))
# print('-------')
for i in range(len(y_poly)):
line = line_parametric(y_poly[i],y_poly[(i+1)%len(y_poly)])
intersection, t = intersection_of_two_lines(incidence,line)
# print(incidence, line)
if intersection:
p1 = y_poly[i]
p2 = y_poly[(i+1)%len(y_poly)]
# print(p1,p2,intersection)
# print(abs(distance(p1,intersection) + distance(p2,intersection) - distance(p1,p2)))
if abs(distance(p1,intersection) + distance(p2,intersection) - distance(p1,p2))<EPS:
if distinct(p1,intersection) and distinct(p2,intersection):
points.append((t,1))
points = [i[1] for i in sorted(points, key=lambda t: t[0])]
prev = len(points) + 1
while prev > len(points):
prev = len(points)
points = crop(points)
#
#
print('NO' if not len(points) else 'YES')
else:
print('NO')
``` | instruction | 0 | 75,542 | 3 | 151,084 |
No | output | 1 | 75,542 | 3 | 151,085 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
Cowboy Beblop is a funny little boy who likes sitting at his computer. He somehow obtained two elastic hoops in the shape of 2D polygons, which are not necessarily convex. Since there's no gravity on his spaceship, the hoops are standing still in the air. Since the hoops are very elastic, Cowboy Beblop can stretch, rotate, translate or shorten their edges as much as he wants.
For both hoops, you are given the number of their vertices, as well as the position of each vertex, defined by the X , Y and Z coordinates. The vertices are given in the order they're connected: the 1st vertex is connected to the 2nd, which is connected to the 3rd, etc., and the last vertex is connected to the first one. Two hoops are connected if it's impossible to pull them to infinity in different directions by manipulating their edges, without having their edges or vertices intersect at any point – just like when two links of a chain are connected. The polygons' edges do not intersect or overlap.
To make things easier, we say that two polygons are well-connected, if the edges of one polygon cross the area of the other polygon in two different directions (from the upper and lower sides of the plane defined by that polygon) a different number of times.
Cowboy Beblop is fascinated with the hoops he has obtained and he would like to know whether they are well-connected or not. Since he’s busy playing with his dog, Zwei, he’d like you to figure it out for him. He promised you some sweets if you help him!
Input
The first line of input contains an integer n (3 ≤ n ≤ 100 000), which denotes the number of edges of the first polygon. The next N lines each contain the integers x, y and z ( - 1 000 000 ≤ x, y, z ≤ 1 000 000) — coordinates of the vertices, in the manner mentioned above. The next line contains an integer m (3 ≤ m ≤ 100 000) , denoting the number of edges of the second polygon, followed by m lines containing the coordinates of the second polygon’s vertices.
It is guaranteed that both polygons are simple (no self-intersections), and in general that the obtained polygonal lines do not intersect each other. Also, you can assume that no 3 consecutive points of a polygon lie on the same line.
Output
Your output should contain only one line, with the words "YES" or "NO", depending on whether the two given polygons are well-connected.
Example
Input
4
0 0 0
2 0 0
2 2 0
0 2 0
4
1 1 -1
1 1 1
1 3 1
1 3 -1
Output
YES
Note
On the picture below, the two polygons are well-connected, as the edges of the vertical polygon cross the area of the horizontal one exactly once in one direction (for example, from above to below), and zero times in the other (in this case, from below to above). Note that the polygons do not have to be parallel to any of the xy-,xz-,yz- planes in general. <image>
Submitted Solution:
```
majmoo=0
for i in range(10000,99999):
flag=0
for j in range(2,int(i**(0.5))+1):
if i%j==0:
flag=1
if flag==0:
majmoo+=i
print(majmoo)
``` | instruction | 0 | 75,543 | 3 | 151,086 |
No | output | 1 | 75,543 | 3 | 151,087 |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.