message stringlengths 2 44.5k | message_type stringclasses 2 values | message_id int64 0 1 | conversation_id int64 276 109k | cluster float64 23 23 | __index_level_0__ int64 552 217k |
|---|---|---|---|---|---|
Provide tags and a correct Python 3 solution for this coding contest problem.
There are n points on a plane. The i-th point has coordinates (x_i, y_i). You have two horizontal platforms, both of length k. Each platform can be placed anywhere on a plane but it should be placed horizontally (on the same y-coordinate) and have integer borders. If the left border of the platform is (x, y) then the right border is (x + k, y) and all points between borders (including borders) belong to the platform.
Note that platforms can share common points (overlap) and it is not necessary to place both platforms on the same y-coordinate.
When you place both platforms on a plane, all points start falling down decreasing their y-coordinate. If a point collides with some platform at some moment, the point stops and is saved. Points which never collide with any platform are lost.
Your task is to find the maximum number of points you can save if you place both platforms optimally.
You have to answer t independent test cases.
For better understanding, please read the Note section below to see a picture for the first test case.
Input
The first line of the input contains one integer t (1 β€ t β€ 2 β
10^4) β the number of test cases. Then t test cases follow.
The first line of the test case contains two integers n and k (1 β€ n β€ 2 β
10^5; 1 β€ k β€ 10^9) β the number of points and the length of each platform, respectively. The second line of the test case contains n integers x_1, x_2, ..., x_n (1 β€ x_i β€ 10^9), where x_i is x-coordinate of the i-th point. The third line of the input contains n integers y_1, y_2, ..., y_n (1 β€ y_i β€ 10^9), where y_i is y-coordinate of the i-th point. All points are distinct (there is no pair 1 β€ i < j β€ n such that x_i = x_j and y_i = y_j).
It is guaranteed that the sum of n does not exceed 2 β
10^5 (β n β€ 2 β
10^5).
Output
For each test case, print the answer: the maximum number of points you can save if you place both platforms optimally.
Example
Input
4
7 1
1 5 2 3 1 5 4
1 3 6 7 2 5 4
1 1
1000000000
1000000000
5 10
10 7 5 15 8
20 199 192 219 1904
10 10
15 19 8 17 20 10 9 2 10 19
12 13 6 17 1 14 7 9 19 3
Output
6
1
5
10
Note
The picture corresponding to the first test case of the example:
<image>
Blue dots represent the points, red segments represent the platforms. One of the possible ways is to place the first platform between points (1, -1) and (2, -1) and the second one between points (4, 3) and (5, 3). Vectors represent how the points will fall down. As you can see, the only point we can't save is the point (3, 7) so it falls down infinitely and will be lost. It can be proven that we can't achieve better answer here. Also note that the point (5, 3) doesn't fall at all because it is already on the platform. | instruction | 0 | 39,793 | 23 | 79,586 |
Tags: binary search, dp, sortings, two pointers
Correct Solution:
```
# from bisect import bisect_left, bisect_right
# def solve():
# n, k = map(int, input().split())
# x = list(map(int, input().split()))
# y = list(map(int, input().split()))
# x.sort()
# dp = [0]*len(x)
# ans = 0
# for i in range(len(x)):
# st = x[i] - k
# st_idx = bisect_left(x, st)
# cur_save = i-st_idx+1
# dp[i] = cur_save if i == 0 else max(cur_save, dp[i-1])
# f_idx = bisect_left(x, st-1)
# if x[f_idx] >= st:
# f_idx -= 1
# if f_idx >= 0:
# assert x[f_idx] < st
# prev_save = dp[f_idx] if f_idx >= 0 else 0
# ans = max(ans, cur_save+prev_save)
# # print(x)
# # print(dp)
# print(ans)
def solve():
n, k = map(int, input().split())
x = list(map(int, input().split()))
y = list(map(int, input().split()))
x.sort()
l = [0]*len(x)
r = [0]*len(x)
st = 0
for i in range(len(x)):
while x[i] - k > x[st]:
st += 1
l[i] = i-st+1
if i > 0:
l[i] = max(l[i], l[i-1])
en = len(x)-1
for i in reversed(range(len(x))):
while x[i] + k < x[en]:
en -= 1
r[i] = en-i+1
if i < len(x)-1:
r[i] = max(r[i], r[i+1])
ans = 0
for i in range(len(x)):
if i == len(x)-1:
ans = max(ans, l[i])
else:
ans = max(ans, l[i]+r[i+1])
print(ans)
if __name__ == '__main__':
T = int(input())
for _ in range(T):
solve()
``` | output | 1 | 39,793 | 23 | 79,587 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
There are n points on a plane. The i-th point has coordinates (x_i, y_i). You have two horizontal platforms, both of length k. Each platform can be placed anywhere on a plane but it should be placed horizontally (on the same y-coordinate) and have integer borders. If the left border of the platform is (x, y) then the right border is (x + k, y) and all points between borders (including borders) belong to the platform.
Note that platforms can share common points (overlap) and it is not necessary to place both platforms on the same y-coordinate.
When you place both platforms on a plane, all points start falling down decreasing their y-coordinate. If a point collides with some platform at some moment, the point stops and is saved. Points which never collide with any platform are lost.
Your task is to find the maximum number of points you can save if you place both platforms optimally.
You have to answer t independent test cases.
For better understanding, please read the Note section below to see a picture for the first test case.
Input
The first line of the input contains one integer t (1 β€ t β€ 2 β
10^4) β the number of test cases. Then t test cases follow.
The first line of the test case contains two integers n and k (1 β€ n β€ 2 β
10^5; 1 β€ k β€ 10^9) β the number of points and the length of each platform, respectively. The second line of the test case contains n integers x_1, x_2, ..., x_n (1 β€ x_i β€ 10^9), where x_i is x-coordinate of the i-th point. The third line of the input contains n integers y_1, y_2, ..., y_n (1 β€ y_i β€ 10^9), where y_i is y-coordinate of the i-th point. All points are distinct (there is no pair 1 β€ i < j β€ n such that x_i = x_j and y_i = y_j).
It is guaranteed that the sum of n does not exceed 2 β
10^5 (β n β€ 2 β
10^5).
Output
For each test case, print the answer: the maximum number of points you can save if you place both platforms optimally.
Example
Input
4
7 1
1 5 2 3 1 5 4
1 3 6 7 2 5 4
1 1
1000000000
1000000000
5 10
10 7 5 15 8
20 199 192 219 1904
10 10
15 19 8 17 20 10 9 2 10 19
12 13 6 17 1 14 7 9 19 3
Output
6
1
5
10
Note
The picture corresponding to the first test case of the example:
<image>
Blue dots represent the points, red segments represent the platforms. One of the possible ways is to place the first platform between points (1, -1) and (2, -1) and the second one between points (4, 3) and (5, 3). Vectors represent how the points will fall down. As you can see, the only point we can't save is the point (3, 7) so it falls down infinitely and will be lost. It can be proven that we can't achieve better answer here. Also note that the point (5, 3) doesn't fall at all because it is already on the platform.
Submitted Solution:
```
t = int(input().strip())
for _ in range(t):
n, k = map(int, input().split())
arr = [int(i) for i in input().split()]
xx = input()
if n == 1:
print(1)
else:
arr.sort()
cnt = [0 for i in range(n)]
left = arr[0]
right = left + k
for i in range(n):
if arr[i] <= right:
cnt[0] += 1
else:
break
index = 1
right_point = i
cons = 1
while index < n:
left = arr[index]
#print(arr,cnt,left,right_point)
if arr[index] != arr[index - 1]:
cnt[index] = (cnt[index - 1] - cons)
cons = 1
for i in range(right_point, n):
if arr[i] > left + k:
right_point = i
break
if i == n - 1:
right_point = n
cnt[index] += 1
else:
cons += 1
cnt[index] = cnt[index - 1]
index += 1
dp = [0 for i in range(n + 1)]
for i in range(n - 1, -1, -1):
dp[i] = max(dp[i + 1], cnt[i])
ans = 0
for i in range(n):
result = cnt[i] + (0 if i + cnt[i] >= n else dp[i + cnt[i]])
if result > ans:
ans = result
print(ans)
``` | instruction | 0 | 39,794 | 23 | 79,588 |
Yes | output | 1 | 39,794 | 23 | 79,589 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
There are n points on a plane. The i-th point has coordinates (x_i, y_i). You have two horizontal platforms, both of length k. Each platform can be placed anywhere on a plane but it should be placed horizontally (on the same y-coordinate) and have integer borders. If the left border of the platform is (x, y) then the right border is (x + k, y) and all points between borders (including borders) belong to the platform.
Note that platforms can share common points (overlap) and it is not necessary to place both platforms on the same y-coordinate.
When you place both platforms on a plane, all points start falling down decreasing their y-coordinate. If a point collides with some platform at some moment, the point stops and is saved. Points which never collide with any platform are lost.
Your task is to find the maximum number of points you can save if you place both platforms optimally.
You have to answer t independent test cases.
For better understanding, please read the Note section below to see a picture for the first test case.
Input
The first line of the input contains one integer t (1 β€ t β€ 2 β
10^4) β the number of test cases. Then t test cases follow.
The first line of the test case contains two integers n and k (1 β€ n β€ 2 β
10^5; 1 β€ k β€ 10^9) β the number of points and the length of each platform, respectively. The second line of the test case contains n integers x_1, x_2, ..., x_n (1 β€ x_i β€ 10^9), where x_i is x-coordinate of the i-th point. The third line of the input contains n integers y_1, y_2, ..., y_n (1 β€ y_i β€ 10^9), where y_i is y-coordinate of the i-th point. All points are distinct (there is no pair 1 β€ i < j β€ n such that x_i = x_j and y_i = y_j).
It is guaranteed that the sum of n does not exceed 2 β
10^5 (β n β€ 2 β
10^5).
Output
For each test case, print the answer: the maximum number of points you can save if you place both platforms optimally.
Example
Input
4
7 1
1 5 2 3 1 5 4
1 3 6 7 2 5 4
1 1
1000000000
1000000000
5 10
10 7 5 15 8
20 199 192 219 1904
10 10
15 19 8 17 20 10 9 2 10 19
12 13 6 17 1 14 7 9 19 3
Output
6
1
5
10
Note
The picture corresponding to the first test case of the example:
<image>
Blue dots represent the points, red segments represent the platforms. One of the possible ways is to place the first platform between points (1, -1) and (2, -1) and the second one between points (4, 3) and (5, 3). Vectors represent how the points will fall down. As you can see, the only point we can't save is the point (3, 7) so it falls down infinitely and will be lost. It can be proven that we can't achieve better answer here. Also note that the point (5, 3) doesn't fall at all because it is already on the platform.
Submitted Solution:
```
def arr(A,k):
n=len(A)
pre=[0]*n
l=0
r=0
while r<n:
if abs(A[r]-A[l])<=k:
r+=1
else:
while l<r and abs(A[r]-A[l])>k:
l+=1
r+=1
pre[r-1]=r-l
return pre
def answer(n,k,A):
if n==1:
return 1
A.sort()
pre=arr(A,k)
suff=arr(A[::-1],k)
suff=suff[::-1]
maxip=[0]*n
maxi=0
maxis=[0]*n
for i in range(n):
maxi=max(maxi,pre[i])
maxip[i]=maxi
maxi=0
for i in range(n-1,-1,-1):
maxi=max(maxi,suff[i])
maxis[i]=maxi
maxi=0
for i in range(n-1):
maxi=max(maxi,maxip[i]+maxis[i+1])
return maxi
t=int(input())
for i in range(t):
n,k=map(int,input().split())
arr1=list(map(int,input().split()))
arr2=list(map(int,input().split()))
print(answer(n,k,arr1))
``` | instruction | 0 | 39,795 | 23 | 79,590 |
Yes | output | 1 | 39,795 | 23 | 79,591 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
There are n points on a plane. The i-th point has coordinates (x_i, y_i). You have two horizontal platforms, both of length k. Each platform can be placed anywhere on a plane but it should be placed horizontally (on the same y-coordinate) and have integer borders. If the left border of the platform is (x, y) then the right border is (x + k, y) and all points between borders (including borders) belong to the platform.
Note that platforms can share common points (overlap) and it is not necessary to place both platforms on the same y-coordinate.
When you place both platforms on a plane, all points start falling down decreasing their y-coordinate. If a point collides with some platform at some moment, the point stops and is saved. Points which never collide with any platform are lost.
Your task is to find the maximum number of points you can save if you place both platforms optimally.
You have to answer t independent test cases.
For better understanding, please read the Note section below to see a picture for the first test case.
Input
The first line of the input contains one integer t (1 β€ t β€ 2 β
10^4) β the number of test cases. Then t test cases follow.
The first line of the test case contains two integers n and k (1 β€ n β€ 2 β
10^5; 1 β€ k β€ 10^9) β the number of points and the length of each platform, respectively. The second line of the test case contains n integers x_1, x_2, ..., x_n (1 β€ x_i β€ 10^9), where x_i is x-coordinate of the i-th point. The third line of the input contains n integers y_1, y_2, ..., y_n (1 β€ y_i β€ 10^9), where y_i is y-coordinate of the i-th point. All points are distinct (there is no pair 1 β€ i < j β€ n such that x_i = x_j and y_i = y_j).
It is guaranteed that the sum of n does not exceed 2 β
10^5 (β n β€ 2 β
10^5).
Output
For each test case, print the answer: the maximum number of points you can save if you place both platforms optimally.
Example
Input
4
7 1
1 5 2 3 1 5 4
1 3 6 7 2 5 4
1 1
1000000000
1000000000
5 10
10 7 5 15 8
20 199 192 219 1904
10 10
15 19 8 17 20 10 9 2 10 19
12 13 6 17 1 14 7 9 19 3
Output
6
1
5
10
Note
The picture corresponding to the first test case of the example:
<image>
Blue dots represent the points, red segments represent the platforms. One of the possible ways is to place the first platform between points (1, -1) and (2, -1) and the second one between points (4, 3) and (5, 3). Vectors represent how the points will fall down. As you can see, the only point we can't save is the point (3, 7) so it falls down infinitely and will be lost. It can be proven that we can't achieve better answer here. Also note that the point (5, 3) doesn't fall at all because it is already on the platform.
Submitted Solution:
```
import bisect
T = int(input())
r = 1
while r<=T:
n,k = map(int,input().split())
x = list(map(int,input().split()))
y = list(map(int,input().split()))
x = sorted(x)
if x[-1]-x[0]<=2*k+1:
print(n)
r += 1
continue
cur = [0]*n
for i in range(n):
cur[i] = bisect.bisect(x,x[i]+k)-bisect.bisect_left(x,x[i])
maxcur = [0]*n
maxcur[-1] = cur[-1]
for i in range(n-2,-1,-1):
maxcur[i] = max(cur[i],maxcur[i+1])
ans = 0
for i in range(n):
if bisect.bisect(x,x[i]+k)<n:
ans = max(ans, cur[i]+maxcur[bisect.bisect(x,x[i]+k)] )
print(ans)
r += 1
``` | instruction | 0 | 39,796 | 23 | 79,592 |
Yes | output | 1 | 39,796 | 23 | 79,593 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
There are n points on a plane. The i-th point has coordinates (x_i, y_i). You have two horizontal platforms, both of length k. Each platform can be placed anywhere on a plane but it should be placed horizontally (on the same y-coordinate) and have integer borders. If the left border of the platform is (x, y) then the right border is (x + k, y) and all points between borders (including borders) belong to the platform.
Note that platforms can share common points (overlap) and it is not necessary to place both platforms on the same y-coordinate.
When you place both platforms on a plane, all points start falling down decreasing their y-coordinate. If a point collides with some platform at some moment, the point stops and is saved. Points which never collide with any platform are lost.
Your task is to find the maximum number of points you can save if you place both platforms optimally.
You have to answer t independent test cases.
For better understanding, please read the Note section below to see a picture for the first test case.
Input
The first line of the input contains one integer t (1 β€ t β€ 2 β
10^4) β the number of test cases. Then t test cases follow.
The first line of the test case contains two integers n and k (1 β€ n β€ 2 β
10^5; 1 β€ k β€ 10^9) β the number of points and the length of each platform, respectively. The second line of the test case contains n integers x_1, x_2, ..., x_n (1 β€ x_i β€ 10^9), where x_i is x-coordinate of the i-th point. The third line of the input contains n integers y_1, y_2, ..., y_n (1 β€ y_i β€ 10^9), where y_i is y-coordinate of the i-th point. All points are distinct (there is no pair 1 β€ i < j β€ n such that x_i = x_j and y_i = y_j).
It is guaranteed that the sum of n does not exceed 2 β
10^5 (β n β€ 2 β
10^5).
Output
For each test case, print the answer: the maximum number of points you can save if you place both platforms optimally.
Example
Input
4
7 1
1 5 2 3 1 5 4
1 3 6 7 2 5 4
1 1
1000000000
1000000000
5 10
10 7 5 15 8
20 199 192 219 1904
10 10
15 19 8 17 20 10 9 2 10 19
12 13 6 17 1 14 7 9 19 3
Output
6
1
5
10
Note
The picture corresponding to the first test case of the example:
<image>
Blue dots represent the points, red segments represent the platforms. One of the possible ways is to place the first platform between points (1, -1) and (2, -1) and the second one between points (4, 3) and (5, 3). Vectors represent how the points will fall down. As you can see, the only point we can't save is the point (3, 7) so it falls down infinitely and will be lost. It can be proven that we can't achieve better answer here. Also note that the point (5, 3) doesn't fall at all because it is already on the platform.
Submitted Solution:
```
from sys import stdin, stdout
t=int(stdin.readline())
for _ in range(t):
n,k=map(int,stdin.readline().split())
x=list(map(int,stdin.readline().split()))
y=stdin.readline()
if n==1:
print(1)
continue
endi=[1]*n
starti=[1]*n
x.sort()
curri=0
i=1
while i<n:
if x[i]-x[curri]<k:
endi[i]=i-curri+1
i+=1
elif x[i]-x[curri]==k:
endi[i]=i-curri+1
i+=1
else:
curri+=1
for i in range(1,n):
endi[i]=max(endi[i],endi[i-1])
curri=n-1
i=n-2
while i>=0:
if x[curri]-x[i]<k:
starti[i]=curri-i+1
i-=1
elif x[curri]-x[i]==k:
starti[i]=curri-i+1
i-=1
else:
curri-=1
for i in range(n-2,-1,-1):
starti[i]=max(starti[i],starti[i+1])
maxi=x.count(x[0])
for i in range(n-1):
s=endi[i]+starti[i+1]
if s>maxi:
maxi=s
print(maxi)
``` | instruction | 0 | 39,797 | 23 | 79,594 |
Yes | output | 1 | 39,797 | 23 | 79,595 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
There are n points on a plane. The i-th point has coordinates (x_i, y_i). You have two horizontal platforms, both of length k. Each platform can be placed anywhere on a plane but it should be placed horizontally (on the same y-coordinate) and have integer borders. If the left border of the platform is (x, y) then the right border is (x + k, y) and all points between borders (including borders) belong to the platform.
Note that platforms can share common points (overlap) and it is not necessary to place both platforms on the same y-coordinate.
When you place both platforms on a plane, all points start falling down decreasing their y-coordinate. If a point collides with some platform at some moment, the point stops and is saved. Points which never collide with any platform are lost.
Your task is to find the maximum number of points you can save if you place both platforms optimally.
You have to answer t independent test cases.
For better understanding, please read the Note section below to see a picture for the first test case.
Input
The first line of the input contains one integer t (1 β€ t β€ 2 β
10^4) β the number of test cases. Then t test cases follow.
The first line of the test case contains two integers n and k (1 β€ n β€ 2 β
10^5; 1 β€ k β€ 10^9) β the number of points and the length of each platform, respectively. The second line of the test case contains n integers x_1, x_2, ..., x_n (1 β€ x_i β€ 10^9), where x_i is x-coordinate of the i-th point. The third line of the input contains n integers y_1, y_2, ..., y_n (1 β€ y_i β€ 10^9), where y_i is y-coordinate of the i-th point. All points are distinct (there is no pair 1 β€ i < j β€ n such that x_i = x_j and y_i = y_j).
It is guaranteed that the sum of n does not exceed 2 β
10^5 (β n β€ 2 β
10^5).
Output
For each test case, print the answer: the maximum number of points you can save if you place both platforms optimally.
Example
Input
4
7 1
1 5 2 3 1 5 4
1 3 6 7 2 5 4
1 1
1000000000
1000000000
5 10
10 7 5 15 8
20 199 192 219 1904
10 10
15 19 8 17 20 10 9 2 10 19
12 13 6 17 1 14 7 9 19 3
Output
6
1
5
10
Note
The picture corresponding to the first test case of the example:
<image>
Blue dots represent the points, red segments represent the platforms. One of the possible ways is to place the first platform between points (1, -1) and (2, -1) and the second one between points (4, 3) and (5, 3). Vectors represent how the points will fall down. As you can see, the only point we can't save is the point (3, 7) so it falls down infinitely and will be lost. It can be proven that we can't achieve better answer here. Also note that the point (5, 3) doesn't fall at all because it is already on the platform.
Submitted Solution:
```
import sys
input = sys.stdin.readline
t = int(input())
for _ in range(t):
n,k = list(map(int,input().split()))
x = list(map(int,input().split()))
y = list(map(int,input().split()))
x.sort()
#print(x)
pl = []
i = 0
j = 0
tmp = []
for z in range(n):
j=z
if x[j]-x[i]>k:
pl.append((i,j-1))
while i<len(x) and x[j] - x[i] >k:
i += 1
if z==n-1:
while i<len(x) and x[j] - x[i] >k:
i += 1
pl.append((i,j))
# print(pl)
rr = list(pl)
rr.sort(key=lambda x: x[1])
if len(x)<3:
print(len(x))
else:
best = 0
ans = 0
j = 0
for i in range(len(pl)):
l,r = pl[i][0], pl[i][1]
best = max(best, rr[j][1] - rr[j][0] + 1)
if l<=rr[j][1]:
ans = max(ans, r - rr[j][0] + 1)
else:
ans = max(ans, r - l + 1 + best)
while rr[j][1] < l:
best = max(best, rr[j][1] - rr[j][0] + 1)
if l<=rr[j][1]:
ans = max(ans, r - rr[j][0] + 1)
else:
ans = max(ans, r - l + 1 + best)
j += 1
best = max(best, rr[j][1] - rr[j][0] + 1)
if l<=rr[j][1]:
ans = max(ans, r - rr[j][0] + 1)
else:
ans = max(ans, r - l + 1 + best)
print(ans)
``` | instruction | 0 | 39,798 | 23 | 79,596 |
No | output | 1 | 39,798 | 23 | 79,597 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
There are n points on a plane. The i-th point has coordinates (x_i, y_i). You have two horizontal platforms, both of length k. Each platform can be placed anywhere on a plane but it should be placed horizontally (on the same y-coordinate) and have integer borders. If the left border of the platform is (x, y) then the right border is (x + k, y) and all points between borders (including borders) belong to the platform.
Note that platforms can share common points (overlap) and it is not necessary to place both platforms on the same y-coordinate.
When you place both platforms on a plane, all points start falling down decreasing their y-coordinate. If a point collides with some platform at some moment, the point stops and is saved. Points which never collide with any platform are lost.
Your task is to find the maximum number of points you can save if you place both platforms optimally.
You have to answer t independent test cases.
For better understanding, please read the Note section below to see a picture for the first test case.
Input
The first line of the input contains one integer t (1 β€ t β€ 2 β
10^4) β the number of test cases. Then t test cases follow.
The first line of the test case contains two integers n and k (1 β€ n β€ 2 β
10^5; 1 β€ k β€ 10^9) β the number of points and the length of each platform, respectively. The second line of the test case contains n integers x_1, x_2, ..., x_n (1 β€ x_i β€ 10^9), where x_i is x-coordinate of the i-th point. The third line of the input contains n integers y_1, y_2, ..., y_n (1 β€ y_i β€ 10^9), where y_i is y-coordinate of the i-th point. All points are distinct (there is no pair 1 β€ i < j β€ n such that x_i = x_j and y_i = y_j).
It is guaranteed that the sum of n does not exceed 2 β
10^5 (β n β€ 2 β
10^5).
Output
For each test case, print the answer: the maximum number of points you can save if you place both platforms optimally.
Example
Input
4
7 1
1 5 2 3 1 5 4
1 3 6 7 2 5 4
1 1
1000000000
1000000000
5 10
10 7 5 15 8
20 199 192 219 1904
10 10
15 19 8 17 20 10 9 2 10 19
12 13 6 17 1 14 7 9 19 3
Output
6
1
5
10
Note
The picture corresponding to the first test case of the example:
<image>
Blue dots represent the points, red segments represent the platforms. One of the possible ways is to place the first platform between points (1, -1) and (2, -1) and the second one between points (4, 3) and (5, 3). Vectors represent how the points will fall down. As you can see, the only point we can't save is the point (3, 7) so it falls down infinitely and will be lost. It can be proven that we can't achieve better answer here. Also note that the point (5, 3) doesn't fall at all because it is already on the platform.
Submitted Solution:
```
from bisect import bisect_right as bs
from bisect import bisect_left as bl
t=int(input())
def answer(q):
a,s,e=0,0,0
for i in range(len(q)):
j=bs(q,q[i]+k)-1
if j-i+1>a:
a=j-i+1
s=i
e=j
return(a,s,e)
def answer2(q):
a,s,e=0,0,0
for i in range(len(q)-1,-1,-1):
j=bl(q,q[i]-k)
if i-j+1>a:
a=i-j+1
s=j
e=i
return(a,s,e)
for _ in range(t):
n,k=map(int,input().split())
x=list(map(int,input().split()))
y=list(map(int,input().split()))
x.sort()
a,s,e=answer(x)
b,s,e=answer(x[:s]+x[e+1:])
c,s,e=answer2(x)
d,s,e=answer2(x[:s]+x[e+1:])
print(max(a+b,c+d))
``` | instruction | 0 | 39,799 | 23 | 79,598 |
No | output | 1 | 39,799 | 23 | 79,599 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
There are n points on a plane. The i-th point has coordinates (x_i, y_i). You have two horizontal platforms, both of length k. Each platform can be placed anywhere on a plane but it should be placed horizontally (on the same y-coordinate) and have integer borders. If the left border of the platform is (x, y) then the right border is (x + k, y) and all points between borders (including borders) belong to the platform.
Note that platforms can share common points (overlap) and it is not necessary to place both platforms on the same y-coordinate.
When you place both platforms on a plane, all points start falling down decreasing their y-coordinate. If a point collides with some platform at some moment, the point stops and is saved. Points which never collide with any platform are lost.
Your task is to find the maximum number of points you can save if you place both platforms optimally.
You have to answer t independent test cases.
For better understanding, please read the Note section below to see a picture for the first test case.
Input
The first line of the input contains one integer t (1 β€ t β€ 2 β
10^4) β the number of test cases. Then t test cases follow.
The first line of the test case contains two integers n and k (1 β€ n β€ 2 β
10^5; 1 β€ k β€ 10^9) β the number of points and the length of each platform, respectively. The second line of the test case contains n integers x_1, x_2, ..., x_n (1 β€ x_i β€ 10^9), where x_i is x-coordinate of the i-th point. The third line of the input contains n integers y_1, y_2, ..., y_n (1 β€ y_i β€ 10^9), where y_i is y-coordinate of the i-th point. All points are distinct (there is no pair 1 β€ i < j β€ n such that x_i = x_j and y_i = y_j).
It is guaranteed that the sum of n does not exceed 2 β
10^5 (β n β€ 2 β
10^5).
Output
For each test case, print the answer: the maximum number of points you can save if you place both platforms optimally.
Example
Input
4
7 1
1 5 2 3 1 5 4
1 3 6 7 2 5 4
1 1
1000000000
1000000000
5 10
10 7 5 15 8
20 199 192 219 1904
10 10
15 19 8 17 20 10 9 2 10 19
12 13 6 17 1 14 7 9 19 3
Output
6
1
5
10
Note
The picture corresponding to the first test case of the example:
<image>
Blue dots represent the points, red segments represent the platforms. One of the possible ways is to place the first platform between points (1, -1) and (2, -1) and the second one between points (4, 3) and (5, 3). Vectors represent how the points will fall down. As you can see, the only point we can't save is the point (3, 7) so it falls down infinitely and will be lost. It can be proven that we can't achieve better answer here. Also note that the point (5, 3) doesn't fall at all because it is already on the platform.
Submitted Solution:
```
for t in range(int(input())):
n, k = map(int, input().split())
xs = sorted(list(map(int, input().split())))
#if t==2309:
# print("{}A{}A{}".format(n,k,"".join(map(str, xs))))
input()
best = 0
i=j=0
while j<n:
while j<n and xs[j]<=xs[i]+k:
j+=1
if best<j-i:
best=j-i
best_start=i
best_end=j
i+=1
i=j=0
best2=0
while j<best_start:
while j<best_start and xs[j]<=xs[i]+k:
j+=1
if best2<j-i:
best2=j-i
i+=1
i=j=best_end
while j<n:
while j<n and xs[j]<=xs[i]+k:
j+=1
if best2<j-i:
best2=j-i
i+=1
best+=best2
j=best_start
while j>-1 and xs[j]+k>xs[best_start]:
j-=1
last = best_start-j
goodies = [(best_start, last)]
if j==-1: j=0
for i in range(best_start+1, best_end-1):
while xs[j]+k<xs[i]:
j+=1
if i-j+1>last:
last = i-j+1
goodies.append((i, last))
j=best_end-1
best2=0
while j<n and xs[j]+k>xs[best_end-1]:
j+=1
if j==n: j=n-1
for i in range(best_end-1, best_start, -1):
while xs[i]+k<xs[j]:
j-=1
if i==goodies[-1][0]:
goodies.pop()
if j-i+1+goodies[-1][1]>best2:
best2=j-i+1+goodies[-1][1]
print(max(best, best2))
``` | instruction | 0 | 39,800 | 23 | 79,600 |
No | output | 1 | 39,800 | 23 | 79,601 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
There are n points on a plane. The i-th point has coordinates (x_i, y_i). You have two horizontal platforms, both of length k. Each platform can be placed anywhere on a plane but it should be placed horizontally (on the same y-coordinate) and have integer borders. If the left border of the platform is (x, y) then the right border is (x + k, y) and all points between borders (including borders) belong to the platform.
Note that platforms can share common points (overlap) and it is not necessary to place both platforms on the same y-coordinate.
When you place both platforms on a plane, all points start falling down decreasing their y-coordinate. If a point collides with some platform at some moment, the point stops and is saved. Points which never collide with any platform are lost.
Your task is to find the maximum number of points you can save if you place both platforms optimally.
You have to answer t independent test cases.
For better understanding, please read the Note section below to see a picture for the first test case.
Input
The first line of the input contains one integer t (1 β€ t β€ 2 β
10^4) β the number of test cases. Then t test cases follow.
The first line of the test case contains two integers n and k (1 β€ n β€ 2 β
10^5; 1 β€ k β€ 10^9) β the number of points and the length of each platform, respectively. The second line of the test case contains n integers x_1, x_2, ..., x_n (1 β€ x_i β€ 10^9), where x_i is x-coordinate of the i-th point. The third line of the input contains n integers y_1, y_2, ..., y_n (1 β€ y_i β€ 10^9), where y_i is y-coordinate of the i-th point. All points are distinct (there is no pair 1 β€ i < j β€ n such that x_i = x_j and y_i = y_j).
It is guaranteed that the sum of n does not exceed 2 β
10^5 (β n β€ 2 β
10^5).
Output
For each test case, print the answer: the maximum number of points you can save if you place both platforms optimally.
Example
Input
4
7 1
1 5 2 3 1 5 4
1 3 6 7 2 5 4
1 1
1000000000
1000000000
5 10
10 7 5 15 8
20 199 192 219 1904
10 10
15 19 8 17 20 10 9 2 10 19
12 13 6 17 1 14 7 9 19 3
Output
6
1
5
10
Note
The picture corresponding to the first test case of the example:
<image>
Blue dots represent the points, red segments represent the platforms. One of the possible ways is to place the first platform between points (1, -1) and (2, -1) and the second one between points (4, 3) and (5, 3). Vectors represent how the points will fall down. As you can see, the only point we can't save is the point (3, 7) so it falls down infinitely and will be lost. It can be proven that we can't achieve better answer here. Also note that the point (5, 3) doesn't fall at all because it is already on the platform.
Submitted Solution:
```
import sys
input = sys.stdin.readline
t = int(input())
for _ in range(t):
n,k = list(map(int,input().split()))
x = list(map(int,input().split()))
y = list(map(int,input().split()))
x.sort()
#print(x)
pl = []
i = 0
j = 0
tmp = []
for j in range(n):
if x[j]-x[i]>k:
pl.append((i,j-1))
while i<len(x) and x[j] - x[i] >k:
i += 1
if j==n-1:
while i<len(x) and x[j] - x[i] >k:
i += 1
pl.append((i,j))
# print(pl)
rr = list(pl)
rr.sort(key=lambda x: x[1])
if len(x)<3:
print(len(x))
else:
best = 0
ans = 0
j = 0
for i in range(len(pl)):
l,r = pl[i][0], pl[i][1]
if l<=rr[j][1]:
ans = max(ans, r - rr[j][0] + 1)
else:
best = max(best, rr[j][1] - rr[j][0] + 1)
ans = max(ans, r - l + 1 + best)
while rr[j][1] < l:
if l<=rr[j][1]:
ans = max(ans, r - rr[j][0] + 1)
else:
best = max(best, rr[j][1] - rr[j][0] + 1)
ans = max(ans, r - l + 1 + best)
j += 1
if l<=rr[j][1]:
ans = max(ans, r - rr[j][0] + 1)
else:
best = max(best, rr[j][1] - rr[j][0] + 1)
ans = max(ans, r - l + 1 + best)
print(ans)
``` | instruction | 0 | 39,801 | 23 | 79,602 |
No | output | 1 | 39,801 | 23 | 79,603 |
Provide tags and a correct Python 3 solution for this coding contest problem.
Nezzar loves the game osu!.
osu! is played on beatmaps, which can be seen as an array consisting of distinct points on a plane. A beatmap is called nice if for any three consecutive points A,B,C listed in order, the angle between these three points, centered at B, is strictly less than 90 degrees.
<image> Points A,B,C on the left have angle less than 90 degrees, so they can be three consecutive points of a nice beatmap; Points A',B',C' on the right have angle greater or equal to 90 degrees, so they cannot be three consecutive points of a nice beatmap.
Now Nezzar has a beatmap of n distinct points A_1,A_2,β¦,A_n. Nezzar would like to reorder these n points so that the resulting beatmap is nice.
Formally, you are required to find a permutation p_1,p_2,β¦,p_n of integers from 1 to n, such that beatmap A_{p_1},A_{p_2},β¦,A_{p_n} is nice. If it is impossible, you should determine it.
Input
The first line contains a single integer n (3 β€ n β€ 5000).
Then n lines follow, i-th of them contains two integers x_i, y_i (-10^9 β€ x_i, y_i β€ 10^9) β coordinates of point A_i.
It is guaranteed that all points are distinct.
Output
If there is no solution, print -1.
Otherwise, print n integers, representing a valid permutation p.
If there are multiple possible answers, you can print any.
Example
Input
5
0 0
5 0
4 2
2 1
3 0
Output
1 2 5 3 4
Note
Here is the illustration for the first test:
<image>
Please note that the angle between A_1, A_2 and A_5, centered at A_2, is treated as 0 degrees. However, angle between A_1, A_5 and A_2, centered at A_5, is treated as 180 degrees. | instruction | 0 | 39,832 | 23 | 79,664 |
Tags: constructive algorithms, geometry, greedy, math, sortings
Correct Solution:
```
from sys import stdin, stdout
from collections import defaultdict
import math
def main():
n = int(stdin.readline())
p = []
for _ in range(n):
x,y = list(map(int, stdin.readline().split()))
p.append((x,y))
ans = []
for i in range(n):
ans.append(i)
for j in range(i, 1,-1):
if (p[ans[j]][0] - p[ans[j-1]][0]) * (p[ans[j-1]][0] - p[ans[j-2]][0]) + (p[ans[j]][1] - p[ans[j-1]][1]) * (p[ans[j-1]][1] - p[ans[j-2]][1]) >= 0:
ans[j-1], ans[j] = ans[j], ans[j-1]
else:
break
stdout.write(" ".join(str(x+1) for x in ans))
main()
``` | output | 1 | 39,832 | 23 | 79,665 |
Provide tags and a correct Python 3 solution for this coding contest problem.
Nezzar loves the game osu!.
osu! is played on beatmaps, which can be seen as an array consisting of distinct points on a plane. A beatmap is called nice if for any three consecutive points A,B,C listed in order, the angle between these three points, centered at B, is strictly less than 90 degrees.
<image> Points A,B,C on the left have angle less than 90 degrees, so they can be three consecutive points of a nice beatmap; Points A',B',C' on the right have angle greater or equal to 90 degrees, so they cannot be three consecutive points of a nice beatmap.
Now Nezzar has a beatmap of n distinct points A_1,A_2,β¦,A_n. Nezzar would like to reorder these n points so that the resulting beatmap is nice.
Formally, you are required to find a permutation p_1,p_2,β¦,p_n of integers from 1 to n, such that beatmap A_{p_1},A_{p_2},β¦,A_{p_n} is nice. If it is impossible, you should determine it.
Input
The first line contains a single integer n (3 β€ n β€ 5000).
Then n lines follow, i-th of them contains two integers x_i, y_i (-10^9 β€ x_i, y_i β€ 10^9) β coordinates of point A_i.
It is guaranteed that all points are distinct.
Output
If there is no solution, print -1.
Otherwise, print n integers, representing a valid permutation p.
If there are multiple possible answers, you can print any.
Example
Input
5
0 0
5 0
4 2
2 1
3 0
Output
1 2 5 3 4
Note
Here is the illustration for the first test:
<image>
Please note that the angle between A_1, A_2 and A_5, centered at A_2, is treated as 0 degrees. However, angle between A_1, A_5 and A_2, centered at A_5, is treated as 180 degrees. | instruction | 0 | 39,833 | 23 | 79,666 |
Tags: constructive algorithms, geometry, greedy, math, sortings
Correct Solution:
```
import sys
#import re
#sys.stdin=open('forest.in','r')
#sys.stdout=open('forest.out','w')
#import math
#import queue
#import random
#sys.setrecursionlimit(int(1e6))
input = sys.stdin.readline
############ ---- USER DEFINED INPUT FUNCTIONS ---- ############
def inp():
return(int(input()))
def inara():
return(list(map(int,input().split())))
def insr():
s = input()
return(list(s[:len(s) - 1]))
def invr():
return(map(int,input().split()))
################################################################
############ ---- THE ACTUAL CODE STARTS BELOW ---- ############
class Vector:
def __init__(self,x,y,id):
self.x=x
self.y=y
self.id=id
def __add__(self,other):
return Vector(self.x+other.x,self.y+other.y,0)
def __sub__(self,other):
return Vector(self.x-other.x,self.y-other.y,0)
def scale(self,n):
return Vector(self.x*n,self.y*n)
def dot(self,other):
return self.x*other.x+self.y*other.y
def cross(self,other):
return self.x*other.y-other.x*self.y
def mag2(self):
return dot(self)
def rot90(self):
return Vector(-self.y,self.x)
def rot270(self):
return Vector(self.y,-self.x)
def hashCode(self):
return self.x<<13^(self.y*57)
def __eq__(self,other):
return self.x==other.x and self.y==other.y
def __lt__(self,other):
if self.x!=other.x:
return self.x<other.x
return self.y<other.y
n=inp()
point=[]
for i in range(n):
x,y=invr()
point.append(Vector(x,y,i+1))
while 1:
flag=True
for i in range(n-2):
x=point[i]
y=point[i+1]
z=point[i+2]
a=y-x
b=z-y
if a.dot(b)>=0:
point[i+1],point[i+2]=point[i+2],point[i+1]
flag=False
if flag:
break
for p in point:
print(p.id,end=" ")
``` | output | 1 | 39,833 | 23 | 79,667 |
Provide tags and a correct Python 3 solution for this coding contest problem.
Nezzar loves the game osu!.
osu! is played on beatmaps, which can be seen as an array consisting of distinct points on a plane. A beatmap is called nice if for any three consecutive points A,B,C listed in order, the angle between these three points, centered at B, is strictly less than 90 degrees.
<image> Points A,B,C on the left have angle less than 90 degrees, so they can be three consecutive points of a nice beatmap; Points A',B',C' on the right have angle greater or equal to 90 degrees, so they cannot be three consecutive points of a nice beatmap.
Now Nezzar has a beatmap of n distinct points A_1,A_2,β¦,A_n. Nezzar would like to reorder these n points so that the resulting beatmap is nice.
Formally, you are required to find a permutation p_1,p_2,β¦,p_n of integers from 1 to n, such that beatmap A_{p_1},A_{p_2},β¦,A_{p_n} is nice. If it is impossible, you should determine it.
Input
The first line contains a single integer n (3 β€ n β€ 5000).
Then n lines follow, i-th of them contains two integers x_i, y_i (-10^9 β€ x_i, y_i β€ 10^9) β coordinates of point A_i.
It is guaranteed that all points are distinct.
Output
If there is no solution, print -1.
Otherwise, print n integers, representing a valid permutation p.
If there are multiple possible answers, you can print any.
Example
Input
5
0 0
5 0
4 2
2 1
3 0
Output
1 2 5 3 4
Note
Here is the illustration for the first test:
<image>
Please note that the angle between A_1, A_2 and A_5, centered at A_2, is treated as 0 degrees. However, angle between A_1, A_5 and A_2, centered at A_5, is treated as 180 degrees. | instruction | 0 | 39,834 | 23 | 79,668 |
Tags: constructive algorithms, geometry, greedy, math, sortings
Correct Solution:
```
import os,io,math
input=io.BytesIO(os.read(0,os.fstat(0).st_size)).readline
points=[]
n=int(input())
visited=[0]*n
visited[0]=1
for i in range(n):
x,y=map(int,input().split())
points.append(x)
points.append(y)
ans=['1']
currx=points[0]
curry=points[1]
for i in range(n-1):
maxdist=0
best=-1
for j in range(n):
if visited[j]:
continue
nextx=points[2*j]
nexty=points[2*j+1]
dist=(nextx-currx)*(nextx-currx)+(nexty-curry)*(nexty-curry)
if maxdist<dist:
maxdist=dist
best=j
ans.append(str(best+1))
visited[best]=1
currx=points[2*best]
curry=points[2*best+1]
print(' '.join(ans))
``` | output | 1 | 39,834 | 23 | 79,669 |
Provide tags and a correct Python 3 solution for this coding contest problem.
Nezzar loves the game osu!.
osu! is played on beatmaps, which can be seen as an array consisting of distinct points on a plane. A beatmap is called nice if for any three consecutive points A,B,C listed in order, the angle between these three points, centered at B, is strictly less than 90 degrees.
<image> Points A,B,C on the left have angle less than 90 degrees, so they can be three consecutive points of a nice beatmap; Points A',B',C' on the right have angle greater or equal to 90 degrees, so they cannot be three consecutive points of a nice beatmap.
Now Nezzar has a beatmap of n distinct points A_1,A_2,β¦,A_n. Nezzar would like to reorder these n points so that the resulting beatmap is nice.
Formally, you are required to find a permutation p_1,p_2,β¦,p_n of integers from 1 to n, such that beatmap A_{p_1},A_{p_2},β¦,A_{p_n} is nice. If it is impossible, you should determine it.
Input
The first line contains a single integer n (3 β€ n β€ 5000).
Then n lines follow, i-th of them contains two integers x_i, y_i (-10^9 β€ x_i, y_i β€ 10^9) β coordinates of point A_i.
It is guaranteed that all points are distinct.
Output
If there is no solution, print -1.
Otherwise, print n integers, representing a valid permutation p.
If there are multiple possible answers, you can print any.
Example
Input
5
0 0
5 0
4 2
2 1
3 0
Output
1 2 5 3 4
Note
Here is the illustration for the first test:
<image>
Please note that the angle between A_1, A_2 and A_5, centered at A_2, is treated as 0 degrees. However, angle between A_1, A_5 and A_2, centered at A_5, is treated as 180 degrees. | instruction | 0 | 39,835 | 23 | 79,670 |
Tags: constructive algorithms, geometry, greedy, math, sortings
Correct Solution:
```
import os,io
input=io.BytesIO(os.read(0,os.fstat(0).st_size)).readline
points=[]
n=int(input())
visited=[0]*n
visited[0]=1
for i in range(n):
x,y=map(int,input().split())
points.append(x)
points.append(y)
ans=['1']
currx=points[0]
curry=points[1]
for i in range(n-1):
maxdist=0
best=-1
for j in range(n):
if visited[j]:
continue
nextx=points[2*j]
nexty=points[2*j+1]
dist=(nextx-currx)*(nextx-currx)+(nexty-curry)*(nexty-curry)
if maxdist<dist:
maxdist=dist
best=j
ans.append(str(best+1))
visited[best]=1
currx=points[2*best]
curry=points[2*best+1]
print(' '.join(ans))
``` | output | 1 | 39,835 | 23 | 79,671 |
Provide tags and a correct Python 3 solution for this coding contest problem.
Nezzar loves the game osu!.
osu! is played on beatmaps, which can be seen as an array consisting of distinct points on a plane. A beatmap is called nice if for any three consecutive points A,B,C listed in order, the angle between these three points, centered at B, is strictly less than 90 degrees.
<image> Points A,B,C on the left have angle less than 90 degrees, so they can be three consecutive points of a nice beatmap; Points A',B',C' on the right have angle greater or equal to 90 degrees, so they cannot be three consecutive points of a nice beatmap.
Now Nezzar has a beatmap of n distinct points A_1,A_2,β¦,A_n. Nezzar would like to reorder these n points so that the resulting beatmap is nice.
Formally, you are required to find a permutation p_1,p_2,β¦,p_n of integers from 1 to n, such that beatmap A_{p_1},A_{p_2},β¦,A_{p_n} is nice. If it is impossible, you should determine it.
Input
The first line contains a single integer n (3 β€ n β€ 5000).
Then n lines follow, i-th of them contains two integers x_i, y_i (-10^9 β€ x_i, y_i β€ 10^9) β coordinates of point A_i.
It is guaranteed that all points are distinct.
Output
If there is no solution, print -1.
Otherwise, print n integers, representing a valid permutation p.
If there are multiple possible answers, you can print any.
Example
Input
5
0 0
5 0
4 2
2 1
3 0
Output
1 2 5 3 4
Note
Here is the illustration for the first test:
<image>
Please note that the angle between A_1, A_2 and A_5, centered at A_2, is treated as 0 degrees. However, angle between A_1, A_5 and A_2, centered at A_5, is treated as 180 degrees. | instruction | 0 | 39,836 | 23 | 79,672 |
Tags: constructive algorithms, geometry, greedy, math, sortings
Correct Solution:
```
import sys,os,io
# input = sys.stdin.readline
input = io.BytesIO(os.read(0,os.fstat(0).st_size)).readline
N = int(input())
# X,Y = [0]*N,[0]*N
points = []
for i in range(N):
# X[i],Y[i] = map(int, input().split())
x,y = map(int, input().split())
points.append(x)
points.append(y)
lis = [0]*N
lis[0] = 1
ans = [str(1)]
now = 0
for _ in range(N-1):
max_d = 0
max_i = -1
for i in range(N):
if lis[i]: continue
d = (points[i*2]-points[now*2])*(points[i*2]-points[now*2])+(points[i*2+1]-points[now*2+1])*(points[i*2+1]-points[now*2+1])
if d>max_d:
max_d = d
max_i = i
lis[max_i] = 1
ans.append(str(max_i+1))
now = max_i
print(' '.join(ans))
``` | output | 1 | 39,836 | 23 | 79,673 |
Provide tags and a correct Python 3 solution for this coding contest problem.
Nezzar loves the game osu!.
osu! is played on beatmaps, which can be seen as an array consisting of distinct points on a plane. A beatmap is called nice if for any three consecutive points A,B,C listed in order, the angle between these three points, centered at B, is strictly less than 90 degrees.
<image> Points A,B,C on the left have angle less than 90 degrees, so they can be three consecutive points of a nice beatmap; Points A',B',C' on the right have angle greater or equal to 90 degrees, so they cannot be three consecutive points of a nice beatmap.
Now Nezzar has a beatmap of n distinct points A_1,A_2,β¦,A_n. Nezzar would like to reorder these n points so that the resulting beatmap is nice.
Formally, you are required to find a permutation p_1,p_2,β¦,p_n of integers from 1 to n, such that beatmap A_{p_1},A_{p_2},β¦,A_{p_n} is nice. If it is impossible, you should determine it.
Input
The first line contains a single integer n (3 β€ n β€ 5000).
Then n lines follow, i-th of them contains two integers x_i, y_i (-10^9 β€ x_i, y_i β€ 10^9) β coordinates of point A_i.
It is guaranteed that all points are distinct.
Output
If there is no solution, print -1.
Otherwise, print n integers, representing a valid permutation p.
If there are multiple possible answers, you can print any.
Example
Input
5
0 0
5 0
4 2
2 1
3 0
Output
1 2 5 3 4
Note
Here is the illustration for the first test:
<image>
Please note that the angle between A_1, A_2 and A_5, centered at A_2, is treated as 0 degrees. However, angle between A_1, A_5 and A_2, centered at A_5, is treated as 180 degrees. | instruction | 0 | 39,837 | 23 | 79,674 |
Tags: constructive algorithms, geometry, greedy, math, sortings
Correct Solution:
```
import sys
#import re
#sys.stdin=open('forest.in','r')
#sys.stdout=open('forest.out','w')
#import math
#import queue
#import random
#sys.setrecursionlimit(int(1e6))
input = sys.stdin.readline
############ ---- USER DEFINED INPUT FUNCTIONS ---- ############
def inp():
return(int(input()))
def inara():
return(list(map(int,input().split())))
def insr():
s = input()
return(list(s[:len(s) - 1]))
def invr():
return(map(int,input().split()))
################################################################
############ ---- THE ACTUAL CODE STARTS BELOW ---- ############
class Vector:
def __init__(self,x,y,id):
self.x=x
self.y=y
self.id=id
def __add__(self,other):
return Vector(self.x+other.x,self.y+other.y,0)
def __sub__(self,other):
return Vector(self.x-other.x,self.y-other.y,0)
def scale(self,n):
return Vector(self.x*n,self.y*n)
def dot(self,other):
return self.x*other.x+self.y*other.y
def cross(self,other):
return self.x*other.y-other.x*self.y
def mag2(self):
return dot(self)
def rot90(self):
return Vector(-self.y,self.x)
def rot270(self):
return Vector(self.y,-self.x)
def hashCode(self):
return self.x<<13^(self.y*57)
def __eq__(self,other):
return self.x==other.x and self.y==other.y
def __lt__(self,other):
if self.x!=other.x:
return self.x<other.x
return self.y<other.y
n=inp()
point=[]
for i in range(n):
x,y=invr()
point.append(Vector(x,y,i+1))
point.sort()
while 1:
flag=True
for i in range(n-2):
x=point[i]
y=point[i+1]
z=point[i+2]
a=y-x
b=z-y
if a.dot(b)>=0:
point[i+1],point[i+2]=point[i+2],point[i+1]
flag=False
if flag:
break
for p in point:
print(p.id,end=" ")
``` | output | 1 | 39,837 | 23 | 79,675 |
Provide tags and a correct Python 3 solution for this coding contest problem.
Nezzar loves the game osu!.
osu! is played on beatmaps, which can be seen as an array consisting of distinct points on a plane. A beatmap is called nice if for any three consecutive points A,B,C listed in order, the angle between these three points, centered at B, is strictly less than 90 degrees.
<image> Points A,B,C on the left have angle less than 90 degrees, so they can be three consecutive points of a nice beatmap; Points A',B',C' on the right have angle greater or equal to 90 degrees, so they cannot be three consecutive points of a nice beatmap.
Now Nezzar has a beatmap of n distinct points A_1,A_2,β¦,A_n. Nezzar would like to reorder these n points so that the resulting beatmap is nice.
Formally, you are required to find a permutation p_1,p_2,β¦,p_n of integers from 1 to n, such that beatmap A_{p_1},A_{p_2},β¦,A_{p_n} is nice. If it is impossible, you should determine it.
Input
The first line contains a single integer n (3 β€ n β€ 5000).
Then n lines follow, i-th of them contains two integers x_i, y_i (-10^9 β€ x_i, y_i β€ 10^9) β coordinates of point A_i.
It is guaranteed that all points are distinct.
Output
If there is no solution, print -1.
Otherwise, print n integers, representing a valid permutation p.
If there are multiple possible answers, you can print any.
Example
Input
5
0 0
5 0
4 2
2 1
3 0
Output
1 2 5 3 4
Note
Here is the illustration for the first test:
<image>
Please note that the angle between A_1, A_2 and A_5, centered at A_2, is treated as 0 degrees. However, angle between A_1, A_5 and A_2, centered at A_5, is treated as 180 degrees. | instruction | 0 | 39,838 | 23 | 79,676 |
Tags: constructive algorithms, geometry, greedy, math, sortings
Correct Solution:
```
# angles <= 60 degrees even I think
n = int(input())
points = [list(map(int,input().split())) for i in range(n)]
pointsx = [points[i][0] for i in range(n)]
pointsy = [points[i][1] for i in range(n)]
vis = [0]*n
order = [0]
vis[0] = 1
for i in range(n-1):
max_dist = 0
best_points = [-1]
lastx = pointsx[order[-1]]
lasty = pointsy[order[-1]]
for j in range(n):
if not vis[j]:
curr_dist_from_last = (pointsx[j]-lastx) * (pointsx[j]-lastx) + (pointsy[j]-lasty) * (pointsy[j]-lasty)
if max_dist < curr_dist_from_last:
max_dist = curr_dist_from_last
best_point = j
order.append(best_point)
vis[best_point] = 1
for i in range(n):
print(order[i]+1)
``` | output | 1 | 39,838 | 23 | 79,677 |
Provide tags and a correct Python 3 solution for this coding contest problem.
Nezzar loves the game osu!.
osu! is played on beatmaps, which can be seen as an array consisting of distinct points on a plane. A beatmap is called nice if for any three consecutive points A,B,C listed in order, the angle between these three points, centered at B, is strictly less than 90 degrees.
<image> Points A,B,C on the left have angle less than 90 degrees, so they can be three consecutive points of a nice beatmap; Points A',B',C' on the right have angle greater or equal to 90 degrees, so they cannot be three consecutive points of a nice beatmap.
Now Nezzar has a beatmap of n distinct points A_1,A_2,β¦,A_n. Nezzar would like to reorder these n points so that the resulting beatmap is nice.
Formally, you are required to find a permutation p_1,p_2,β¦,p_n of integers from 1 to n, such that beatmap A_{p_1},A_{p_2},β¦,A_{p_n} is nice. If it is impossible, you should determine it.
Input
The first line contains a single integer n (3 β€ n β€ 5000).
Then n lines follow, i-th of them contains two integers x_i, y_i (-10^9 β€ x_i, y_i β€ 10^9) β coordinates of point A_i.
It is guaranteed that all points are distinct.
Output
If there is no solution, print -1.
Otherwise, print n integers, representing a valid permutation p.
If there are multiple possible answers, you can print any.
Example
Input
5
0 0
5 0
4 2
2 1
3 0
Output
1 2 5 3 4
Note
Here is the illustration for the first test:
<image>
Please note that the angle between A_1, A_2 and A_5, centered at A_2, is treated as 0 degrees. However, angle between A_1, A_5 and A_2, centered at A_5, is treated as 180 degrees. | instruction | 0 | 39,839 | 23 | 79,678 |
Tags: constructive algorithms, geometry, greedy, math, sortings
Correct Solution:
```
import sys
input = sys.stdin.readline
n=int(input())
A=[0]+[tuple(map(int,input().split())) for i in range(n)]
ANS=[1,2]
def judge(x,y,z):
if (A[x][0]-A[y][0])*(A[z][0]-A[y][0])+(A[x][1]-A[y][1])*(A[z][1]-A[y][1])>0:
return 1
else:
return 0
for i in range(3,n+1):
if judge(i,ANS[-1],ANS[-2])==1:
ANS.append(i)
continue
for j in range(1,len(ANS)):
if judge(ANS[j-1],i,ANS[j])==1:
if j==1 or judge(ANS[j-2],ANS[j-1],i)==1:
if j==len(ANS)-1 or judge(i,ANS[j],ANS[j+1])==1:
ANS=ANS[:j]+[i]+ANS[j:]
break
#print(ANS)
else:
print(pow(2,10**(10**9)))
print(*ANS)
``` | output | 1 | 39,839 | 23 | 79,679 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
Nezzar loves the game osu!.
osu! is played on beatmaps, which can be seen as an array consisting of distinct points on a plane. A beatmap is called nice if for any three consecutive points A,B,C listed in order, the angle between these three points, centered at B, is strictly less than 90 degrees.
<image> Points A,B,C on the left have angle less than 90 degrees, so they can be three consecutive points of a nice beatmap; Points A',B',C' on the right have angle greater or equal to 90 degrees, so they cannot be three consecutive points of a nice beatmap.
Now Nezzar has a beatmap of n distinct points A_1,A_2,β¦,A_n. Nezzar would like to reorder these n points so that the resulting beatmap is nice.
Formally, you are required to find a permutation p_1,p_2,β¦,p_n of integers from 1 to n, such that beatmap A_{p_1},A_{p_2},β¦,A_{p_n} is nice. If it is impossible, you should determine it.
Input
The first line contains a single integer n (3 β€ n β€ 5000).
Then n lines follow, i-th of them contains two integers x_i, y_i (-10^9 β€ x_i, y_i β€ 10^9) β coordinates of point A_i.
It is guaranteed that all points are distinct.
Output
If there is no solution, print -1.
Otherwise, print n integers, representing a valid permutation p.
If there are multiple possible answers, you can print any.
Example
Input
5
0 0
5 0
4 2
2 1
3 0
Output
1 2 5 3 4
Note
Here is the illustration for the first test:
<image>
Please note that the angle between A_1, A_2 and A_5, centered at A_2, is treated as 0 degrees. However, angle between A_1, A_5 and A_2, centered at A_5, is treated as 180 degrees.
Submitted Solution:
```
class Node:
def __init__(self, x, y):
self.x = x
self.y = y
def getDist(self, a):
dx = a.x - self.x
dy = a.y - self.y
return dx * dx + dy * dy
n = int(input())
a = []
for i in range(n):
x, y = map(int, input().split())
a.append(Node(x, y))
ans = [0]
vis = set()
vis.add(0)
while len(ans) < n:
cur = ans[-1]
maxDis = 0
maxPos = 0
for j in range(n):
if cur == j or j in vis:
continue
val = a[cur].getDist(a[j])
if val > maxDis:
maxDis = val
maxPos = j
vis.add(maxPos)
ans.append(maxPos)
for i in ans:
print(i+1, end = ' ')
print()
``` | instruction | 0 | 39,840 | 23 | 79,680 |
Yes | output | 1 | 39,840 | 23 | 79,681 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
Nezzar loves the game osu!.
osu! is played on beatmaps, which can be seen as an array consisting of distinct points on a plane. A beatmap is called nice if for any three consecutive points A,B,C listed in order, the angle between these three points, centered at B, is strictly less than 90 degrees.
<image> Points A,B,C on the left have angle less than 90 degrees, so they can be three consecutive points of a nice beatmap; Points A',B',C' on the right have angle greater or equal to 90 degrees, so they cannot be three consecutive points of a nice beatmap.
Now Nezzar has a beatmap of n distinct points A_1,A_2,β¦,A_n. Nezzar would like to reorder these n points so that the resulting beatmap is nice.
Formally, you are required to find a permutation p_1,p_2,β¦,p_n of integers from 1 to n, such that beatmap A_{p_1},A_{p_2},β¦,A_{p_n} is nice. If it is impossible, you should determine it.
Input
The first line contains a single integer n (3 β€ n β€ 5000).
Then n lines follow, i-th of them contains two integers x_i, y_i (-10^9 β€ x_i, y_i β€ 10^9) β coordinates of point A_i.
It is guaranteed that all points are distinct.
Output
If there is no solution, print -1.
Otherwise, print n integers, representing a valid permutation p.
If there are multiple possible answers, you can print any.
Example
Input
5
0 0
5 0
4 2
2 1
3 0
Output
1 2 5 3 4
Note
Here is the illustration for the first test:
<image>
Please note that the angle between A_1, A_2 and A_5, centered at A_2, is treated as 0 degrees. However, angle between A_1, A_5 and A_2, centered at A_5, is treated as 180 degrees.
Submitted Solution:
```
#!/usr/bin/env python
import os
import sys
from io import BytesIO, IOBase
def main():
n = int(input())
points = []
for _ in range(n):
points.append(list(map(int,input().split())))
ans = [1]
isCovered = [False] * n
isCovered[0] = True
curAns = 0
for i in range(n - 1):
maxDist = 0
maxDistVertex = -1
for j in range(n):
if (not isCovered[j]) and (points[j][0] - points[curAns][0]) * (points[j][0] - points[curAns][0]) + (points[j][1] - points[curAns][1]) * (points[j][1] - points[curAns][1]) > maxDist:
maxDist = (points[j][0] - points[curAns][0]) * (points[j][0] - points[curAns][0]) + (points[j][1] - points[curAns][1]) * (points[j][1] - points[curAns][1])
maxDistVertex = j
ans.append(maxDistVertex + 1)
isCovered[maxDistVertex] = True
curAns = maxDistVertex
print(" ".join(map(str,ans)))
# region fastio
BUFSIZE = 8192
class FastIO(IOBase):
newlines = 0
def __init__(self, file):
self._fd = file.fileno()
self.buffer = BytesIO()
self.writable = "x" in file.mode or "r" not in file.mode
self.write = self.buffer.write if self.writable else None
def read(self):
while True:
b = os.read(self._fd, max(os.fstat(self._fd).st_size, BUFSIZE))
if not b:
break
ptr = self.buffer.tell()
self.buffer.seek(0, 2), self.buffer.write(b), self.buffer.seek(ptr)
self.newlines = 0
return self.buffer.read()
def readline(self):
while self.newlines == 0:
b = os.read(self._fd, max(os.fstat(self._fd).st_size, BUFSIZE))
self.newlines = b.count(b"\n") + (not b)
ptr = self.buffer.tell()
self.buffer.seek(0, 2), self.buffer.write(b), self.buffer.seek(ptr)
self.newlines -= 1
return self.buffer.readline()
def flush(self):
if self.writable:
os.write(self._fd, self.buffer.getvalue())
self.buffer.truncate(0), self.buffer.seek(0)
class IOWrapper(IOBase):
def __init__(self, file):
self.buffer = FastIO(file)
self.flush = self.buffer.flush
self.writable = self.buffer.writable
self.write = lambda s: self.buffer.write(s.encode("ascii"))
self.read = lambda: self.buffer.read().decode("ascii")
self.readline = lambda: self.buffer.readline().decode("ascii")
sys.stdin, sys.stdout = IOWrapper(sys.stdin), IOWrapper(sys.stdout)
input = lambda: sys.stdin.readline().rstrip("\r\n")
# endregion
if __name__ == "__main__":
main()
``` | instruction | 0 | 39,841 | 23 | 79,682 |
Yes | output | 1 | 39,841 | 23 | 79,683 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
Nezzar loves the game osu!.
osu! is played on beatmaps, which can be seen as an array consisting of distinct points on a plane. A beatmap is called nice if for any three consecutive points A,B,C listed in order, the angle between these three points, centered at B, is strictly less than 90 degrees.
<image> Points A,B,C on the left have angle less than 90 degrees, so they can be three consecutive points of a nice beatmap; Points A',B',C' on the right have angle greater or equal to 90 degrees, so they cannot be three consecutive points of a nice beatmap.
Now Nezzar has a beatmap of n distinct points A_1,A_2,β¦,A_n. Nezzar would like to reorder these n points so that the resulting beatmap is nice.
Formally, you are required to find a permutation p_1,p_2,β¦,p_n of integers from 1 to n, such that beatmap A_{p_1},A_{p_2},β¦,A_{p_n} is nice. If it is impossible, you should determine it.
Input
The first line contains a single integer n (3 β€ n β€ 5000).
Then n lines follow, i-th of them contains two integers x_i, y_i (-10^9 β€ x_i, y_i β€ 10^9) β coordinates of point A_i.
It is guaranteed that all points are distinct.
Output
If there is no solution, print -1.
Otherwise, print n integers, representing a valid permutation p.
If there are multiple possible answers, you can print any.
Example
Input
5
0 0
5 0
4 2
2 1
3 0
Output
1 2 5 3 4
Note
Here is the illustration for the first test:
<image>
Please note that the angle between A_1, A_2 and A_5, centered at A_2, is treated as 0 degrees. However, angle between A_1, A_5 and A_2, centered at A_5, is treated as 180 degrees.
Submitted Solution:
```
from math import sqrt
# angles <= 60 degrees even I think
n = int(input())
points = [list(map(float,input().split())) for i in range(n)]
vis = [0]*n
order = [0]
vis[0] = 1
for i in range(n-1):
max_dist = 0
best_points = [-1]
for j in range(n):
if not vis[j]:
x = abs(points[j][0] - points[order[-1]][0])
y = abs(points[j][1] - points[order[-1]][1])
curr_dist_from_last = x ** 2 + y ** 2
if max_dist == curr_dist_from_last:
best_points.append(j)
if max_dist < curr_dist_from_last:
max_dist = curr_dist_from_last
best_points = [j]
max_dist = 0
best_point = -1
for j in best_points:
x = int(abs(points[j][0] - points[order[-1]][0]))
y = int(abs(points[j][1] - points[order[-1]][1]))
curr_dist_from_last = x ** 2 + y ** 2
if max_dist < curr_dist_from_last:
max_dist = curr_dist_from_last
best_point = j
order.append(best_point)
vis[best_point] = 1
for i in range(n):
print(order[i]+1)
``` | instruction | 0 | 39,842 | 23 | 79,684 |
Yes | output | 1 | 39,842 | 23 | 79,685 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
Nezzar loves the game osu!.
osu! is played on beatmaps, which can be seen as an array consisting of distinct points on a plane. A beatmap is called nice if for any three consecutive points A,B,C listed in order, the angle between these three points, centered at B, is strictly less than 90 degrees.
<image> Points A,B,C on the left have angle less than 90 degrees, so they can be three consecutive points of a nice beatmap; Points A',B',C' on the right have angle greater or equal to 90 degrees, so they cannot be three consecutive points of a nice beatmap.
Now Nezzar has a beatmap of n distinct points A_1,A_2,β¦,A_n. Nezzar would like to reorder these n points so that the resulting beatmap is nice.
Formally, you are required to find a permutation p_1,p_2,β¦,p_n of integers from 1 to n, such that beatmap A_{p_1},A_{p_2},β¦,A_{p_n} is nice. If it is impossible, you should determine it.
Input
The first line contains a single integer n (3 β€ n β€ 5000).
Then n lines follow, i-th of them contains two integers x_i, y_i (-10^9 β€ x_i, y_i β€ 10^9) β coordinates of point A_i.
It is guaranteed that all points are distinct.
Output
If there is no solution, print -1.
Otherwise, print n integers, representing a valid permutation p.
If there are multiple possible answers, you can print any.
Example
Input
5
0 0
5 0
4 2
2 1
3 0
Output
1 2 5 3 4
Note
Here is the illustration for the first test:
<image>
Please note that the angle between A_1, A_2 and A_5, centered at A_2, is treated as 0 degrees. However, angle between A_1, A_5 and A_2, centered at A_5, is treated as 180 degrees.
Submitted Solution:
```
def solve(N,A):
def check(a,b,c):
ax,ay = a
bx,by = b
cx,cy = c
return (bx-ax) * (cx-bx) + (by-ay) * (cy-by) < 0
ans = [i for i in range(N)]
for i in range(N-2):
for j in range(i,-1,-1):
a,b,c = ans[j],ans[j+1],ans[j+2]
if not check(A[a],A[b],A[c]):
ans[j+1],ans[j+2] = ans[j+2],ans[j+1]
return ans
n = int(input())
A = [tuple(map(int,input().split())) for i in range(n)]
ans = solve(n,A)
for i in range(n):
ans[i] += 1
print(*ans)
``` | instruction | 0 | 39,843 | 23 | 79,686 |
Yes | output | 1 | 39,843 | 23 | 79,687 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
Nezzar loves the game osu!.
osu! is played on beatmaps, which can be seen as an array consisting of distinct points on a plane. A beatmap is called nice if for any three consecutive points A,B,C listed in order, the angle between these three points, centered at B, is strictly less than 90 degrees.
<image> Points A,B,C on the left have angle less than 90 degrees, so they can be three consecutive points of a nice beatmap; Points A',B',C' on the right have angle greater or equal to 90 degrees, so they cannot be three consecutive points of a nice beatmap.
Now Nezzar has a beatmap of n distinct points A_1,A_2,β¦,A_n. Nezzar would like to reorder these n points so that the resulting beatmap is nice.
Formally, you are required to find a permutation p_1,p_2,β¦,p_n of integers from 1 to n, such that beatmap A_{p_1},A_{p_2},β¦,A_{p_n} is nice. If it is impossible, you should determine it.
Input
The first line contains a single integer n (3 β€ n β€ 5000).
Then n lines follow, i-th of them contains two integers x_i, y_i (-10^9 β€ x_i, y_i β€ 10^9) β coordinates of point A_i.
It is guaranteed that all points are distinct.
Output
If there is no solution, print -1.
Otherwise, print n integers, representing a valid permutation p.
If there are multiple possible answers, you can print any.
Example
Input
5
0 0
5 0
4 2
2 1
3 0
Output
1 2 5 3 4
Note
Here is the illustration for the first test:
<image>
Please note that the angle between A_1, A_2 and A_5, centered at A_2, is treated as 0 degrees. However, angle between A_1, A_5 and A_2, centered at A_5, is treated as 180 degrees.
Submitted Solution:
```
import sys,os,io
input = sys.stdin.readline
# input = io.BytesIO(os.read(0,os.fstat(0).st_size)).readline
N = int(input())
X,Y = [0]*N,[0]*N
for i in range(N):
X[i],Y[i] = map(int, input().split())
lis = [False]*N
lis[0] = True
ans = [1]
now = 0
for _ in range(N-1):
max_d = 0
max_i = -1
for i in range(N):
if lis[i]: continue
d = abs(X[i]-X[now])+abs(Y[i]-Y[now])
if d>max_d:
max_d = d
max_i = i
lis[max_i] = True
ans.append(max_i+1)
now = max_i
print(*ans)
``` | instruction | 0 | 39,844 | 23 | 79,688 |
No | output | 1 | 39,844 | 23 | 79,689 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
Nezzar loves the game osu!.
osu! is played on beatmaps, which can be seen as an array consisting of distinct points on a plane. A beatmap is called nice if for any three consecutive points A,B,C listed in order, the angle between these three points, centered at B, is strictly less than 90 degrees.
<image> Points A,B,C on the left have angle less than 90 degrees, so they can be three consecutive points of a nice beatmap; Points A',B',C' on the right have angle greater or equal to 90 degrees, so they cannot be three consecutive points of a nice beatmap.
Now Nezzar has a beatmap of n distinct points A_1,A_2,β¦,A_n. Nezzar would like to reorder these n points so that the resulting beatmap is nice.
Formally, you are required to find a permutation p_1,p_2,β¦,p_n of integers from 1 to n, such that beatmap A_{p_1},A_{p_2},β¦,A_{p_n} is nice. If it is impossible, you should determine it.
Input
The first line contains a single integer n (3 β€ n β€ 5000).
Then n lines follow, i-th of them contains two integers x_i, y_i (-10^9 β€ x_i, y_i β€ 10^9) β coordinates of point A_i.
It is guaranteed that all points are distinct.
Output
If there is no solution, print -1.
Otherwise, print n integers, representing a valid permutation p.
If there are multiple possible answers, you can print any.
Example
Input
5
0 0
5 0
4 2
2 1
3 0
Output
1 2 5 3 4
Note
Here is the illustration for the first test:
<image>
Please note that the angle between A_1, A_2 and A_5, centered at A_2, is treated as 0 degrees. However, angle between A_1, A_5 and A_2, centered at A_5, is treated as 180 degrees.
Submitted Solution:
```
import sys
#import re
#sys.stdin=open('forest.in','r')
#sys.stdout=open('forest.out','w')
#import math
#import queue
#import random
#sys.setrecursionlimit(int(1e6))
input = sys.stdin.readline
############ ---- USER DEFINED INPUT FUNCTIONS ---- ############
def inp():
return(int(input()))
def inara():
return(list(map(int,input().split())))
def insr():
s = input()
return(list(s[:len(s) - 1]))
def invr():
return(map(int,input().split()))
################################################################
############ ---- THE ACTUAL CODE STARTS BELOW ---- ############
class Vector:
def __init__(self,x,y,id):
self.x=x
self.y=y
self.id=id
def __add__(self,other):
return Vector(self.x+other.x,self.y+other.y,0)
def __sub__(self,other):
return Vector(self.x-other.x,self.y-other.y,0)
def scale(self,n):
return Vector(self.x*n,self.y*n)
def dot(self,other):
return self.x*other.x+self.y*other.y
def cross(self,other):
return self.x*other.y-other.x*self.y
def mag2(self):
return dot(self)
def rot90(self):
return Vector(-self.y,self.x)
def rot270(self):
return Vector(self.y,-self.x)
def hashCode(self):
return self.x<<13^(self.y*57)
def __eq__(self,other):
return self.x==other.x and self.y==other.y
def __lt__(self,other):
if self.x!=other.x:
return self.x<other.x
return self.y<other.y
n=inp()
point=[]
for i in range(n):
x,y=invr()
point.append(Vector(x,y,i+1))
point.sort()
for j in range(n):
for i in range(n-2):
x=point[i]
y=point[i+1]
z=point[i+2]
a=y-x
b=z-y
if a.dot(b)>0:
point[i+1],point[i+2]=point[i+2],point[i+1]
for p in point:
print(p.id,end=" ")
``` | instruction | 0 | 39,845 | 23 | 79,690 |
No | output | 1 | 39,845 | 23 | 79,691 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
Nezzar loves the game osu!.
osu! is played on beatmaps, which can be seen as an array consisting of distinct points on a plane. A beatmap is called nice if for any three consecutive points A,B,C listed in order, the angle between these three points, centered at B, is strictly less than 90 degrees.
<image> Points A,B,C on the left have angle less than 90 degrees, so they can be three consecutive points of a nice beatmap; Points A',B',C' on the right have angle greater or equal to 90 degrees, so they cannot be three consecutive points of a nice beatmap.
Now Nezzar has a beatmap of n distinct points A_1,A_2,β¦,A_n. Nezzar would like to reorder these n points so that the resulting beatmap is nice.
Formally, you are required to find a permutation p_1,p_2,β¦,p_n of integers from 1 to n, such that beatmap A_{p_1},A_{p_2},β¦,A_{p_n} is nice. If it is impossible, you should determine it.
Input
The first line contains a single integer n (3 β€ n β€ 5000).
Then n lines follow, i-th of them contains two integers x_i, y_i (-10^9 β€ x_i, y_i β€ 10^9) β coordinates of point A_i.
It is guaranteed that all points are distinct.
Output
If there is no solution, print -1.
Otherwise, print n integers, representing a valid permutation p.
If there are multiple possible answers, you can print any.
Example
Input
5
0 0
5 0
4 2
2 1
3 0
Output
1 2 5 3 4
Note
Here is the illustration for the first test:
<image>
Please note that the angle between A_1, A_2 and A_5, centered at A_2, is treated as 0 degrees. However, angle between A_1, A_5 and A_2, centered at A_5, is treated as 180 degrees.
Submitted Solution:
```
import sys
input = sys.stdin.readline
def get(xx, yy, x, y):
dx, dy = abs(xx - x), abs(yy - y)
return dx**2 + dy**2
n = int(input())
point_list = [[i + 1] + list(map(int, input().split())) for i in range(n)]
res = [point_list[-1][0]]
x, y = point_list[-1][1:]
point_list.pop()
pre = []
for i in range(n - 1):
nxt = 0
if len(point_list) > 1:
if get(*point_list[-1][1:], x, y) > get(*point_list[-2][1:], x, y):
nxt = len(point_list) - 1
else:
nxt = len(point_list) - 2
tmp = point_list.pop(nxt)
# print(pre,[x,y], tmp)
if not pre or (get(*pre, x, y) > get(*pre, *tmp[1:])):
res.append(tmp[0])
pre = [x, y]
x, y = tmp[1:]
else:
res.insert(-1, tmp[0])
pre = tmp[1:]
# print(res)
print(' '.join(map(str, res)))
``` | instruction | 0 | 39,846 | 23 | 79,692 |
No | output | 1 | 39,846 | 23 | 79,693 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
Nezzar loves the game osu!.
osu! is played on beatmaps, which can be seen as an array consisting of distinct points on a plane. A beatmap is called nice if for any three consecutive points A,B,C listed in order, the angle between these three points, centered at B, is strictly less than 90 degrees.
<image> Points A,B,C on the left have angle less than 90 degrees, so they can be three consecutive points of a nice beatmap; Points A',B',C' on the right have angle greater or equal to 90 degrees, so they cannot be three consecutive points of a nice beatmap.
Now Nezzar has a beatmap of n distinct points A_1,A_2,β¦,A_n. Nezzar would like to reorder these n points so that the resulting beatmap is nice.
Formally, you are required to find a permutation p_1,p_2,β¦,p_n of integers from 1 to n, such that beatmap A_{p_1},A_{p_2},β¦,A_{p_n} is nice. If it is impossible, you should determine it.
Input
The first line contains a single integer n (3 β€ n β€ 5000).
Then n lines follow, i-th of them contains two integers x_i, y_i (-10^9 β€ x_i, y_i β€ 10^9) β coordinates of point A_i.
It is guaranteed that all points are distinct.
Output
If there is no solution, print -1.
Otherwise, print n integers, representing a valid permutation p.
If there are multiple possible answers, you can print any.
Example
Input
5
0 0
5 0
4 2
2 1
3 0
Output
1 2 5 3 4
Note
Here is the illustration for the first test:
<image>
Please note that the angle between A_1, A_2 and A_5, centered at A_2, is treated as 0 degrees. However, angle between A_1, A_5 and A_2, centered at A_5, is treated as 180 degrees.
Submitted Solution:
```
#https://codeforces.com/problemset/problem/1477/C
import math
MAXN = 6007
x = [0]*MAXN #two arrays of the maximum size
y = [0]*MAXN
lines = int(input())
perm = []
for line in range(lines) :
xyVals = input().strip().split()
# print("{} {}".format(xyVals[0], xyVals[1]))
x[line] = int(xyVals[0])
y[line] = int(xyVals[1])
for line in range(lines) :
perm.append(line)
checker = line
while checker > 1 :
ang = math.degrees(math.atan2(y[checker] - y[checker-1], x[checker] - x[checker-1]) - math.atan2(y[checker-2] - y[checker-1], x[checker-1] - x[checker-1]))
# if ang < 0 :
# print("Angle {}".format(ang + 360))
# else :
# print("Angle {}".format(ang))
if ang % 180 <= 90 :
temp = perm[checker]
perm[checker] = perm[checker - 1]
perm[checker - 1] = temp
checker -= 1
for x in range(0,lines) :
print(perm[x] + 1, end=" ")
``` | instruction | 0 | 39,847 | 23 | 79,694 |
No | output | 1 | 39,847 | 23 | 79,695 |
Provide tags and a correct Python 3 solution for this coding contest problem.
A widely known among some people Belarusian sport programmer Yura possesses lots of information about cars. That is why he has been invited to participate in a game show called "Guess That Car!".
The game show takes place on a giant parking lot, which is 4n meters long from north to south and 4m meters wide from west to east. The lot has n + 1 dividing lines drawn from west to east and m + 1 dividing lines drawn from north to south, which divide the parking lot into nΒ·m 4 by 4 meter squares. There is a car parked strictly inside each square. The dividing lines are numbered from 0 to n from north to south and from 0 to m from west to east. Each square has coordinates (i, j) so that the square in the north-west corner has coordinates (1, 1) and the square in the south-east corner has coordinates (n, m). See the picture in the notes for clarifications.
Before the game show the organizers offer Yura to occupy any of the (n + 1)Β·(m + 1) intersection points of the dividing lines. After that he can start guessing the cars. After Yura chooses a point, he will be prohibited to move along the parking lot before the end of the game show. As Yura is a car expert, he will always guess all cars he is offered, it's just a matter of time. Yura knows that to guess each car he needs to spend time equal to the square of the euclidean distance between his point and the center of the square with this car, multiplied by some coefficient characterizing the machine's "rarity" (the rarer the car is, the harder it is to guess it). More formally, guessing a car with "rarity" c placed in a square whose center is at distance d from Yura takes cΒ·d2 seconds. The time Yura spends on turning his head can be neglected.
It just so happened that Yura knows the "rarity" of each car on the parking lot in advance. Help him choose his point so that the total time of guessing all cars is the smallest possible.
Input
The first line contains two integers n and m (1 β€ n, m β€ 1000) β the sizes of the parking lot. Each of the next n lines contains m integers: the j-th number in the i-th line describes the "rarity" cij (0 β€ cij β€ 100000) of the car that is located in the square with coordinates (i, j).
Output
In the first line print the minimum total time Yura needs to guess all offered cars. In the second line print two numbers li and lj (0 β€ li β€ n, 0 β€ lj β€ m) β the numbers of dividing lines that form a junction that Yura should choose to stand on at the beginning of the game show. If there are multiple optimal starting points, print the point with smaller li. If there are still multiple such points, print the point with smaller lj.
Please do not use the %lld specifier to read or write 64-bit integers in Π‘++. It is preferred to use the cin, cout streams or the %I64d specifier.
Examples
Input
2 3
3 4 5
3 9 1
Output
392
1 1
Input
3 4
1 0 0 0
0 0 3 0
0 0 5 5
Output
240
2 3
Note
In the first test case the total time of guessing all cars is equal to 3Β·8 + 3Β·8 + 4Β·8 + 9Β·8 + 5Β·40 + 1Β·40 = 392.
The coordinate system of the field:
<image> | instruction | 0 | 39,884 | 23 | 79,768 |
Tags: math, ternary search
Correct Solution:
```
#------------------------template--------------------------#
import os
import sys
# from math import *
from collections import *
# from fractions import *
# from heapq import*
from bisect import *
from io import BytesIO, IOBase
def vsInput():
sys.stdin = open('input.txt', 'r')
sys.stdout = open('output.txt', 'w')
BUFSIZE = 8192
class FastIO(IOBase):
newlines = 0
def __init__(self, file):
self._fd = file.fileno()
self.buffer = BytesIO()
self.writable = "x" in file.mode or "r" not in file.mode
self.write = self.buffer.write if self.writable else None
def read(self):
while True:
b = os.read(self._fd, max(os.fstat(self._fd).st_size, BUFSIZE))
if not b:
break
ptr = self.buffer.tell()
self.buffer.seek(0, 2), self.buffer.write(b), self.buffer.seek(ptr)
self.newlines = 0
return self.buffer.read()
def readline(self):
while self.newlines == 0:
b = os.read(self._fd, max(os.fstat(self._fd).st_size, BUFSIZE))
self.newlines = b.count(b"\n") + (not b)
ptr = self.buffer.tell()
self.buffer.seek(0, 2), self.buffer.write(b), self.buffer.seek(ptr)
self.newlines -= 1
return self.buffer.readline()
def flush(self):
if self.writable:
os.write(self._fd, self.buffer.getvalue())
self.buffer.truncate(0), self.buffer.seek(0)
class IOWrapper(IOBase):
def __init__(self, file):
self.buffer = FastIO(file)
self.flush = self.buffer.flush
self.writable = self.buffer.writable
self.write = lambda s: self.buffer.write(s.encode("ascii"))
self.read = lambda: self.buffer.read().decode("ascii")
self.readline = lambda: self.buffer.readline().decode("ascii")
sys.stdin, sys.stdout = IOWrapper(sys.stdin), IOWrapper(sys.stdout)
input = lambda: sys.stdin.readline().rstrip("\r\n")
ALPHA='abcdefghijklmnopqrstuvwxyz/'
M=998244353
EPS=1e-6
def Ceil(a,b): return a//b+int(a%b>0)
def value():return tuple(map(int,input().split()))
def array():return [int(i) for i in input().split()]
def Int():return int(input())
def Str():return input()
def arrayS():return [i for i in input().split()]
#-------------------------code---------------------------#
# vsInput()
r,c=value()
a=[]
for i in range(r):a.append(array())
row_sum=[0]*r
col_sum=[0]*c
for i in range(r):
for j in range(c):
row_sum[i]+=a[i][j]
col_sum[j]+=a[i][j]
x=[0]*(r+1)
for i in range(r+1):
for row in range(r):
d=abs(4*(row)+2-i*4)
x[i]+=row_sum[row]*(d**2)
y=[0]*(c+1)
for i in range(c+1):
for col in range(c):
d=abs(4*(col)+2-i*4)
y[i]+=col_sum[col]*(d**2)
# print(*x)
# print(*y)
ans=min(x)+min(y)
x=x.index(min(x))
y=y.index(min(y))
print(ans)
print(x,y)
``` | output | 1 | 39,884 | 23 | 79,769 |
Provide tags and a correct Python 3 solution for this coding contest problem.
A widely known among some people Belarusian sport programmer Yura possesses lots of information about cars. That is why he has been invited to participate in a game show called "Guess That Car!".
The game show takes place on a giant parking lot, which is 4n meters long from north to south and 4m meters wide from west to east. The lot has n + 1 dividing lines drawn from west to east and m + 1 dividing lines drawn from north to south, which divide the parking lot into nΒ·m 4 by 4 meter squares. There is a car parked strictly inside each square. The dividing lines are numbered from 0 to n from north to south and from 0 to m from west to east. Each square has coordinates (i, j) so that the square in the north-west corner has coordinates (1, 1) and the square in the south-east corner has coordinates (n, m). See the picture in the notes for clarifications.
Before the game show the organizers offer Yura to occupy any of the (n + 1)Β·(m + 1) intersection points of the dividing lines. After that he can start guessing the cars. After Yura chooses a point, he will be prohibited to move along the parking lot before the end of the game show. As Yura is a car expert, he will always guess all cars he is offered, it's just a matter of time. Yura knows that to guess each car he needs to spend time equal to the square of the euclidean distance between his point and the center of the square with this car, multiplied by some coefficient characterizing the machine's "rarity" (the rarer the car is, the harder it is to guess it). More formally, guessing a car with "rarity" c placed in a square whose center is at distance d from Yura takes cΒ·d2 seconds. The time Yura spends on turning his head can be neglected.
It just so happened that Yura knows the "rarity" of each car on the parking lot in advance. Help him choose his point so that the total time of guessing all cars is the smallest possible.
Input
The first line contains two integers n and m (1 β€ n, m β€ 1000) β the sizes of the parking lot. Each of the next n lines contains m integers: the j-th number in the i-th line describes the "rarity" cij (0 β€ cij β€ 100000) of the car that is located in the square with coordinates (i, j).
Output
In the first line print the minimum total time Yura needs to guess all offered cars. In the second line print two numbers li and lj (0 β€ li β€ n, 0 β€ lj β€ m) β the numbers of dividing lines that form a junction that Yura should choose to stand on at the beginning of the game show. If there are multiple optimal starting points, print the point with smaller li. If there are still multiple such points, print the point with smaller lj.
Please do not use the %lld specifier to read or write 64-bit integers in Π‘++. It is preferred to use the cin, cout streams or the %I64d specifier.
Examples
Input
2 3
3 4 5
3 9 1
Output
392
1 1
Input
3 4
1 0 0 0
0 0 3 0
0 0 5 5
Output
240
2 3
Note
In the first test case the total time of guessing all cars is equal to 3Β·8 + 3Β·8 + 4Β·8 + 9Β·8 + 5Β·40 + 1Β·40 = 392.
The coordinate system of the field:
<image> | instruction | 0 | 39,885 | 23 | 79,770 |
Tags: math, ternary search
Correct Solution:
```
import os
import sys
from io import BytesIO, IOBase
from collections import Counter
BUFSIZE = 8192
class FastIO(IOBase):
newlines = 0
def __init__(self, file):
self._fd = file.fileno()
self.buffer = BytesIO()
self.writable = "x" in file.mode or "r" not in file.mode
self.write = self.buffer.write if self.writable else None
def read(self):
while True:
b = os.read(self._fd, max(os.fstat(self._fd).st_size, BUFSIZE))
if not b:
break
ptr = self.buffer.tell()
self.buffer.seek(0, 2), self.buffer.write(b), self.buffer.seek(ptr)
self.newlines = 0
return self.buffer.read()
def readline(self):
while self.newlines == 0:
b = os.read(self._fd, max(os.fstat(self._fd).st_size, BUFSIZE))
self.newlines = b.count(b"\n") + (not b)
ptr = self.buffer.tell()
self.buffer.seek(0, 2), self.buffer.write(b), self.buffer.seek(ptr)
self.newlines -= 1
return self.buffer.readline()
def flush(self):
if self.writable:
os.write(self._fd, self.buffer.getvalue())
self.buffer.truncate(0), self.buffer.seek(0)
class IOWrapper(IOBase):
def __init__(self, file):
self.buffer = FastIO(file)
self.flush = self.buffer.flush
self.writable = self.buffer.writable
self.write = lambda s: self.buffer.write(s.encode("ascii"))
self.read = lambda: self.buffer.read().decode("ascii")
self.readline = lambda: self.buffer.readline().decode("ascii")
sys.stdin, sys.stdout = IOWrapper(sys.stdin), IOWrapper(sys.stdout)
def gcd(a, b):
if a == 0:
return b
return gcd(b % a, a)
def lcm(a, b):
return (a * b) / gcd(a, b)
def main():
# = int(input())
# = list(map(int, input().split()))
# = input()
n,m=map(int, input().split())
a=[]
somrows=[]
somcols=[]
for i in range(n):
a.append(list(map(int, input().split())))
somrows.append(sum(a[i]))
for j in range(m):
curr=0
for i in range(n):
curr+=a[i][j]
somcols.append(curr)
xs=[]
ys=[]
xmin=ymin=float('inf')
xind=yind=-1
for i in range(0, 4*m+1, 4):
curr=0
for j in range(2, 4*m, 4):
curr+=(j-i)*(j-i)*(somcols[j//4])
if curr<xmin:
xmin=curr
xind=i//4
xs.append(curr)
#print('')
for i in range(0, 4*n+1, 4):
curr=0
for j in range(2, 4*n, 4):
curr+=(j-i)*(j-i)*(somrows[j//4])
ys.append(curr)
if curr<ymin:
ymin=curr
yind=i//4
print(xmin+ymin)
print(yind, xind)
return
if __name__ == "__main__":
main()
``` | output | 1 | 39,885 | 23 | 79,771 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
A widely known among some people Belarusian sport programmer Yura possesses lots of information about cars. That is why he has been invited to participate in a game show called "Guess That Car!".
The game show takes place on a giant parking lot, which is 4n meters long from north to south and 4m meters wide from west to east. The lot has n + 1 dividing lines drawn from west to east and m + 1 dividing lines drawn from north to south, which divide the parking lot into nΒ·m 4 by 4 meter squares. There is a car parked strictly inside each square. The dividing lines are numbered from 0 to n from north to south and from 0 to m from west to east. Each square has coordinates (i, j) so that the square in the north-west corner has coordinates (1, 1) and the square in the south-east corner has coordinates (n, m). See the picture in the notes for clarifications.
Before the game show the organizers offer Yura to occupy any of the (n + 1)Β·(m + 1) intersection points of the dividing lines. After that he can start guessing the cars. After Yura chooses a point, he will be prohibited to move along the parking lot before the end of the game show. As Yura is a car expert, he will always guess all cars he is offered, it's just a matter of time. Yura knows that to guess each car he needs to spend time equal to the square of the euclidean distance between his point and the center of the square with this car, multiplied by some coefficient characterizing the machine's "rarity" (the rarer the car is, the harder it is to guess it). More formally, guessing a car with "rarity" c placed in a square whose center is at distance d from Yura takes cΒ·d2 seconds. The time Yura spends on turning his head can be neglected.
It just so happened that Yura knows the "rarity" of each car on the parking lot in advance. Help him choose his point so that the total time of guessing all cars is the smallest possible.
Input
The first line contains two integers n and m (1 β€ n, m β€ 1000) β the sizes of the parking lot. Each of the next n lines contains m integers: the j-th number in the i-th line describes the "rarity" cij (0 β€ cij β€ 100000) of the car that is located in the square with coordinates (i, j).
Output
In the first line print the minimum total time Yura needs to guess all offered cars. In the second line print two numbers li and lj (0 β€ li β€ n, 0 β€ lj β€ m) β the numbers of dividing lines that form a junction that Yura should choose to stand on at the beginning of the game show. If there are multiple optimal starting points, print the point with smaller li. If there are still multiple such points, print the point with smaller lj.
Please do not use the %lld specifier to read or write 64-bit integers in Π‘++. It is preferred to use the cin, cout streams or the %I64d specifier.
Examples
Input
2 3
3 4 5
3 9 1
Output
392
1 1
Input
3 4
1 0 0 0
0 0 3 0
0 0 5 5
Output
240
2 3
Note
In the first test case the total time of guessing all cars is equal to 3Β·8 + 3Β·8 + 4Β·8 + 9Β·8 + 5Β·40 + 1Β·40 = 392.
The coordinate system of the field:
<image>
Submitted Solution:
```
import os
import sys
from io import BytesIO, IOBase
from collections import Counter
BUFSIZE = 8192
class FastIO(IOBase):
newlines = 0
def __init__(self, file):
self._fd = file.fileno()
self.buffer = BytesIO()
self.writable = "x" in file.mode or "r" not in file.mode
self.write = self.buffer.write if self.writable else None
def read(self):
while True:
b = os.read(self._fd, max(os.fstat(self._fd).st_size, BUFSIZE))
if not b:
break
ptr = self.buffer.tell()
self.buffer.seek(0, 2), self.buffer.write(b), self.buffer.seek(ptr)
self.newlines = 0
return self.buffer.read()
def readline(self):
while self.newlines == 0:
b = os.read(self._fd, max(os.fstat(self._fd).st_size, BUFSIZE))
self.newlines = b.count(b"\n") + (not b)
ptr = self.buffer.tell()
self.buffer.seek(0, 2), self.buffer.write(b), self.buffer.seek(ptr)
self.newlines -= 1
return self.buffer.readline()
def flush(self):
if self.writable:
os.write(self._fd, self.buffer.getvalue())
self.buffer.truncate(0), self.buffer.seek(0)
class IOWrapper(IOBase):
def __init__(self, file):
self.buffer = FastIO(file)
self.flush = self.buffer.flush
self.writable = self.buffer.writable
self.write = lambda s: self.buffer.write(s.encode("ascii"))
self.read = lambda: self.buffer.read().decode("ascii")
self.readline = lambda: self.buffer.readline().decode("ascii")
sys.stdin, sys.stdout = IOWrapper(sys.stdin), IOWrapper(sys.stdout)
def gcd(a, b):
if a == 0:
return b
return gcd(b % a, a)
def lcm(a, b):
return (a * b) / gcd(a, b)
def main():
# = int(input())
# = list(map(int, input().split()))
# = input()
n,m=map(int, input().split())
a=[]
somrows=[]
somcols=[]
for i in range(n):
a.append(list(map(int, input().split())))
somrows.append(sum(a[i]))
for j in range(m):
curr=0
for i in range(n):
curr+=a[i][j]
somcols.append(curr)
xs=[]
ys=[]
xmin=ymin=float('inf')
xind=yind=-1
for i in range(0, 4*m+1, 4):
curr=0
for j in range(2, 4*m, 4):
curr+=(j-i)*(j-i)*(somcols[j//4])
if curr<xmin:
xmin=curr
xind=i//4
xs.append(curr)
#print('')
for i in range(0, 4*n+1, 4):
curr=0
for j in range(2, 4*n, 4):
curr+=(j-i)*(j-i)*(somrows[j//4])
ys.append(curr)
if curr<ymin:
ymin=curr
yind=i//4
print(xmin+ymin)
print(xind, yind)
return
if __name__ == "__main__":
main()
``` | instruction | 0 | 39,886 | 23 | 79,772 |
No | output | 1 | 39,886 | 23 | 79,773 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
Toastman came up with a very easy task. He gives it to Appleman, but Appleman doesn't know how to solve it. Can you help him?
Given a n Γ n checkerboard. Each cell of the board has either character 'x', or character 'o'. Is it true that each cell of the board has even number of adjacent cells with 'o'? Two cells of the board are adjacent if they share a side.
Input
The first line contains an integer n (1 β€ n β€ 100). Then n lines follow containing the description of the checkerboard. Each of them contains n characters (either 'x' or 'o') without spaces.
Output
Print "YES" or "NO" (without the quotes) depending on the answer to the problem.
Examples
Input
3
xxo
xox
oxx
Output
YES
Input
4
xxxo
xoxo
oxox
xxxx
Output
NO
Submitted Solution:
```
from builtins import range
n = int(input())
i=0
g=0
desk = [[]]
for i in range(n):
str = input()
desk.insert(i, [str[g] for g in range(n)])
i=0
g=0
test = True
for i in range(n):
for g in range(n):
res = 0
if(i-1!=-1):
if(desk[i-1][g] == 'o'):
res+=1
if(i+1<n):
if(desk[i+1][g] == 'o'):
res+=1
if(g-1!=-1):
if(desk[i][g-1] == 'o'):
res+=1
if(g+1<n):
if(desk[i][g+1] == 'o'):
res+=1
if(res % 2 == 1):
test = False
break
if(test == False):
break
if(test== True):
print("YES")
else:
print("NO")
``` | instruction | 0 | 39,973 | 23 | 79,946 |
Yes | output | 1 | 39,973 | 23 | 79,947 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
Toastman came up with a very easy task. He gives it to Appleman, but Appleman doesn't know how to solve it. Can you help him?
Given a n Γ n checkerboard. Each cell of the board has either character 'x', or character 'o'. Is it true that each cell of the board has even number of adjacent cells with 'o'? Two cells of the board are adjacent if they share a side.
Input
The first line contains an integer n (1 β€ n β€ 100). Then n lines follow containing the description of the checkerboard. Each of them contains n characters (either 'x' or 'o') without spaces.
Output
Print "YES" or "NO" (without the quotes) depending on the answer to the problem.
Examples
Input
3
xxo
xox
oxx
Output
YES
Input
4
xxxo
xoxo
oxox
xxxx
Output
NO
Submitted Solution:
```
n = int(input())
s = ""
for i in range(n):
s += input()
print("YES" if s == s[::-1] else "NO")
``` | instruction | 0 | 39,974 | 23 | 79,948 |
Yes | output | 1 | 39,974 | 23 | 79,949 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
Toastman came up with a very easy task. He gives it to Appleman, but Appleman doesn't know how to solve it. Can you help him?
Given a n Γ n checkerboard. Each cell of the board has either character 'x', or character 'o'. Is it true that each cell of the board has even number of adjacent cells with 'o'? Two cells of the board are adjacent if they share a side.
Input
The first line contains an integer n (1 β€ n β€ 100). Then n lines follow containing the description of the checkerboard. Each of them contains n characters (either 'x' or 'o') without spaces.
Output
Print "YES" or "NO" (without the quotes) depending on the answer to the problem.
Examples
Input
3
xxo
xox
oxx
Output
YES
Input
4
xxxo
xoxo
oxox
xxxx
Output
NO
Submitted Solution:
```
n = int(input())
d = ['x' * (n + 2)]
for i in range(n):
d.append('x' + input() + 'x')
d.append('x' * (n + 2))
ok = 1
for i in range(1, n+1):
for j in range(1, n+1):
nb = (d[i - 1][j] == 'o') + (d[i + 1][j] == 'o') + (d[i][j - 1] == 'o') + (d[i][j + 1] == 'o')
if nb % 2 != 0:
ok = 0
if ok == 1:
print("YES")
else:
print("NO")
``` | instruction | 0 | 39,975 | 23 | 79,950 |
Yes | output | 1 | 39,975 | 23 | 79,951 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
Toastman came up with a very easy task. He gives it to Appleman, but Appleman doesn't know how to solve it. Can you help him?
Given a n Γ n checkerboard. Each cell of the board has either character 'x', or character 'o'. Is it true that each cell of the board has even number of adjacent cells with 'o'? Two cells of the board are adjacent if they share a side.
Input
The first line contains an integer n (1 β€ n β€ 100). Then n lines follow containing the description of the checkerboard. Each of them contains n characters (either 'x' or 'o') without spaces.
Output
Print "YES" or "NO" (without the quotes) depending on the answer to the problem.
Examples
Input
3
xxo
xox
oxx
Output
YES
Input
4
xxxo
xoxo
oxox
xxxx
Output
NO
Submitted Solution:
```
n = int(input());
square = [list(input()) for i in range(n)];
flag = True;
for i in range(n):
if flag == False:
break;
for j in range(n):
cc = 0;
if i > 0 and square[i-1][j] == 'o':
++cc;
if i < n-1 and square[i+1][j] == 'o':
++cc;
if j > 0 and square[i][j-1] == 'o':
++cc;
if j < n-1 and square[i][j+1] == 'o':
++cc;
if cc%2 == 1:
flag = False;
break;
if flag:
print("YES");
else:
print("NO");
``` | instruction | 0 | 39,977 | 23 | 79,954 |
No | output | 1 | 39,977 | 23 | 79,955 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
Toastman came up with a very easy task. He gives it to Appleman, but Appleman doesn't know how to solve it. Can you help him?
Given a n Γ n checkerboard. Each cell of the board has either character 'x', or character 'o'. Is it true that each cell of the board has even number of adjacent cells with 'o'? Two cells of the board are adjacent if they share a side.
Input
The first line contains an integer n (1 β€ n β€ 100). Then n lines follow containing the description of the checkerboard. Each of them contains n characters (either 'x' or 'o') without spaces.
Output
Print "YES" or "NO" (without the quotes) depending on the answer to the problem.
Examples
Input
3
xxo
xox
oxx
Output
YES
Input
4
xxxo
xoxo
oxox
xxxx
Output
NO
Submitted Solution:
```
def main():
n = int(input())
s = []
for i in range(n):
s.append(input())
for i in range(n):
for j in range(n):
cnt = 0
for di, dj in [(1, 0), (-1, 0), (0, 1), (0, -1)]:
ii = i + di
jj = j + dj
if ii >= 0 and ii < n and jj >= 0 and jj < n and s[i][j] == 'o':
cnt += 1
if cnt % 2:
print("NO")
return
print("YES")
if __name__ == '__main__':
main()
``` | instruction | 0 | 39,978 | 23 | 79,956 |
No | output | 1 | 39,978 | 23 | 79,957 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
Toastman came up with a very easy task. He gives it to Appleman, but Appleman doesn't know how to solve it. Can you help him?
Given a n Γ n checkerboard. Each cell of the board has either character 'x', or character 'o'. Is it true that each cell of the board has even number of adjacent cells with 'o'? Two cells of the board are adjacent if they share a side.
Input
The first line contains an integer n (1 β€ n β€ 100). Then n lines follow containing the description of the checkerboard. Each of them contains n characters (either 'x' or 'o') without spaces.
Output
Print "YES" or "NO" (without the quotes) depending on the answer to the problem.
Examples
Input
3
xxo
xox
oxx
Output
YES
Input
4
xxxo
xoxo
oxox
xxxx
Output
NO
Submitted Solution:
```
n = int(input())
f = 0
for i in range(n):
f = input()
k = 0
for j in range(len(list(f))):
if list(f)[j] == "x":
k+=1
if k%2!=0:
print("NO")
break
if i==j==n and k%2!=0:
print("NO")
break
else:
print("YES")
break
``` | instruction | 0 | 39,979 | 23 | 79,958 |
No | output | 1 | 39,979 | 23 | 79,959 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
Toastman came up with a very easy task. He gives it to Appleman, but Appleman doesn't know how to solve it. Can you help him?
Given a n Γ n checkerboard. Each cell of the board has either character 'x', or character 'o'. Is it true that each cell of the board has even number of adjacent cells with 'o'? Two cells of the board are adjacent if they share a side.
Input
The first line contains an integer n (1 β€ n β€ 100). Then n lines follow containing the description of the checkerboard. Each of them contains n characters (either 'x' or 'o') without spaces.
Output
Print "YES" or "NO" (without the quotes) depending on the answer to the problem.
Examples
Input
3
xxo
xox
oxx
Output
YES
Input
4
xxxo
xoxo
oxox
xxxx
Output
NO
Submitted Solution:
```
import sys
def data():
return sys.stdin.readline().strip()
def sp(): return map(int, data().split())
def l(): return list(sp())
n=int(data())
res=[]
for i in range(n):
res.append(list(data()))
even=0
flag=True
for i in range(n):
for j in range(n):
if i-1>=0 and res[i-1][j]=='o':even+=1
elif i+1<n and res[i+1][j]=='o':even+=1
elif j-1>=0 and res[i][j-1]=='o':even+=1
elif j+1<n and res[i][j+1]=='o':even+=1
elif even%2==1:flag=False
if flag:print('YES')
else:print('NO')
``` | instruction | 0 | 39,980 | 23 | 79,960 |
No | output | 1 | 39,980 | 23 | 79,961 |
Provide tags and a correct Python 3 solution for this coding contest problem.
Gerald got a very curious hexagon for his birthday. The boy found out that all the angles of the hexagon are equal to <image>. Then he measured the length of its sides, and found that each of them is equal to an integer number of centimeters. There the properties of the hexagon ended and Gerald decided to draw on it.
He painted a few lines, parallel to the sides of the hexagon. The lines split the hexagon into regular triangles with sides of 1 centimeter. Now Gerald wonders how many triangles he has got. But there were so many of them that Gerald lost the track of his counting. Help the boy count the triangles.
Input
The first and the single line of the input contains 6 space-separated integers a1, a2, a3, a4, a5 and a6 (1 β€ ai β€ 1000) β the lengths of the sides of the hexagons in centimeters in the clockwise order. It is guaranteed that the hexagon with the indicated properties and the exactly such sides exists.
Output
Print a single integer β the number of triangles with the sides of one 1 centimeter, into which the hexagon is split.
Examples
Input
1 1 1 1 1 1
Output
6
Input
1 2 1 2 1 2
Output
13
Note
This is what Gerald's hexagon looks like in the first sample:
<image>
And that's what it looks like in the second sample:
<image> | instruction | 0 | 40,013 | 23 | 80,026 |
Tags: brute force, geometry, math
Correct Solution:
```
a = [ int(e) for e in input().strip().split() ]
l = (a[0] + a[1] + a[2]) ** 2
n_triangles = l - (a[4] ** 2) - (a[0] ** 2) - (a[2] ** 2)
print(n_triangles)
``` | output | 1 | 40,013 | 23 | 80,027 |
Provide tags and a correct Python 3 solution for this coding contest problem.
Gerald got a very curious hexagon for his birthday. The boy found out that all the angles of the hexagon are equal to <image>. Then he measured the length of its sides, and found that each of them is equal to an integer number of centimeters. There the properties of the hexagon ended and Gerald decided to draw on it.
He painted a few lines, parallel to the sides of the hexagon. The lines split the hexagon into regular triangles with sides of 1 centimeter. Now Gerald wonders how many triangles he has got. But there were so many of them that Gerald lost the track of his counting. Help the boy count the triangles.
Input
The first and the single line of the input contains 6 space-separated integers a1, a2, a3, a4, a5 and a6 (1 β€ ai β€ 1000) β the lengths of the sides of the hexagons in centimeters in the clockwise order. It is guaranteed that the hexagon with the indicated properties and the exactly such sides exists.
Output
Print a single integer β the number of triangles with the sides of one 1 centimeter, into which the hexagon is split.
Examples
Input
1 1 1 1 1 1
Output
6
Input
1 2 1 2 1 2
Output
13
Note
This is what Gerald's hexagon looks like in the first sample:
<image>
And that's what it looks like in the second sample:
<image> | instruction | 0 | 40,014 | 23 | 80,028 |
Tags: brute force, geometry, math
Correct Solution:
```
def tri(s):
return s * s
a, b, c, d, e, f = map(int, input().split())
print(tri(a + b + c) - tri(a) - tri(c) - tri(e))
``` | output | 1 | 40,014 | 23 | 80,029 |
Provide tags and a correct Python 3 solution for this coding contest problem.
Gerald got a very curious hexagon for his birthday. The boy found out that all the angles of the hexagon are equal to <image>. Then he measured the length of its sides, and found that each of them is equal to an integer number of centimeters. There the properties of the hexagon ended and Gerald decided to draw on it.
He painted a few lines, parallel to the sides of the hexagon. The lines split the hexagon into regular triangles with sides of 1 centimeter. Now Gerald wonders how many triangles he has got. But there were so many of them that Gerald lost the track of his counting. Help the boy count the triangles.
Input
The first and the single line of the input contains 6 space-separated integers a1, a2, a3, a4, a5 and a6 (1 β€ ai β€ 1000) β the lengths of the sides of the hexagons in centimeters in the clockwise order. It is guaranteed that the hexagon with the indicated properties and the exactly such sides exists.
Output
Print a single integer β the number of triangles with the sides of one 1 centimeter, into which the hexagon is split.
Examples
Input
1 1 1 1 1 1
Output
6
Input
1 2 1 2 1 2
Output
13
Note
This is what Gerald's hexagon looks like in the first sample:
<image>
And that's what it looks like in the second sample:
<image> | instruction | 0 | 40,015 | 23 | 80,030 |
Tags: brute force, geometry, math
Correct Solution:
```
import sys
input = lambda: sys.stdin.readline().rstrip("\r\n")
a=list(map(int,input().split()))
ans=a[0]
for i in range(a[0]+1,a[0]+min(a[1],a[-1])):
ans+=2*i
for i in range(a[3]+min(a[2],a[4]),a[3],-1):
ans+=i*2
ans+=a[3]+abs(a[1]-a[-1])*(a[0]+min(a[1],a[-1]))*2
print(ans)
``` | output | 1 | 40,015 | 23 | 80,031 |
Provide tags and a correct Python 3 solution for this coding contest problem.
Gerald got a very curious hexagon for his birthday. The boy found out that all the angles of the hexagon are equal to <image>. Then he measured the length of its sides, and found that each of them is equal to an integer number of centimeters. There the properties of the hexagon ended and Gerald decided to draw on it.
He painted a few lines, parallel to the sides of the hexagon. The lines split the hexagon into regular triangles with sides of 1 centimeter. Now Gerald wonders how many triangles he has got. But there were so many of them that Gerald lost the track of his counting. Help the boy count the triangles.
Input
The first and the single line of the input contains 6 space-separated integers a1, a2, a3, a4, a5 and a6 (1 β€ ai β€ 1000) β the lengths of the sides of the hexagons in centimeters in the clockwise order. It is guaranteed that the hexagon with the indicated properties and the exactly such sides exists.
Output
Print a single integer β the number of triangles with the sides of one 1 centimeter, into which the hexagon is split.
Examples
Input
1 1 1 1 1 1
Output
6
Input
1 2 1 2 1 2
Output
13
Note
This is what Gerald's hexagon looks like in the first sample:
<image>
And that's what it looks like in the second sample:
<image> | instruction | 0 | 40,016 | 23 | 80,032 |
Tags: brute force, geometry, math
Correct Solution:
```
start, rsplit, rend, end, lend, lsplit = (int(i) for i in input().split())
start = 2*start + 1 # On first line we have this many triangles
end = 2*end + 1
# This number increases by 2 on each line until we hit one or both edges
# I know, it could be written as a O(1) expression, I'm too lazy
onsplit = start + min(lsplit, rsplit)*2 - 2
triA = sum(range(start, onsplit+2, 2))
triB = (onsplit+1) * abs(rsplit-lsplit) # Then the two lines run in parallel
triC = sum(range(onsplit, end - 2, -2))
print(triA + triB + triC)
``` | output | 1 | 40,016 | 23 | 80,033 |
Provide tags and a correct Python 3 solution for this coding contest problem.
Gerald got a very curious hexagon for his birthday. The boy found out that all the angles of the hexagon are equal to <image>. Then he measured the length of its sides, and found that each of them is equal to an integer number of centimeters. There the properties of the hexagon ended and Gerald decided to draw on it.
He painted a few lines, parallel to the sides of the hexagon. The lines split the hexagon into regular triangles with sides of 1 centimeter. Now Gerald wonders how many triangles he has got. But there were so many of them that Gerald lost the track of his counting. Help the boy count the triangles.
Input
The first and the single line of the input contains 6 space-separated integers a1, a2, a3, a4, a5 and a6 (1 β€ ai β€ 1000) β the lengths of the sides of the hexagons in centimeters in the clockwise order. It is guaranteed that the hexagon with the indicated properties and the exactly such sides exists.
Output
Print a single integer β the number of triangles with the sides of one 1 centimeter, into which the hexagon is split.
Examples
Input
1 1 1 1 1 1
Output
6
Input
1 2 1 2 1 2
Output
13
Note
This is what Gerald's hexagon looks like in the first sample:
<image>
And that's what it looks like in the second sample:
<image> | instruction | 0 | 40,017 | 23 | 80,034 |
Tags: brute force, geometry, math
Correct Solution:
```
'''input
1 1 1 1 1 1
'''
a1, a2, a3, a4, a5, a6 = map(int, input().split())
s = a1 + a2 + a3
print(s**2 - a1**2 - a3**2 - a5**2)
``` | output | 1 | 40,017 | 23 | 80,035 |
Provide tags and a correct Python 3 solution for this coding contest problem.
Gerald got a very curious hexagon for his birthday. The boy found out that all the angles of the hexagon are equal to <image>. Then he measured the length of its sides, and found that each of them is equal to an integer number of centimeters. There the properties of the hexagon ended and Gerald decided to draw on it.
He painted a few lines, parallel to the sides of the hexagon. The lines split the hexagon into regular triangles with sides of 1 centimeter. Now Gerald wonders how many triangles he has got. But there were so many of them that Gerald lost the track of his counting. Help the boy count the triangles.
Input
The first and the single line of the input contains 6 space-separated integers a1, a2, a3, a4, a5 and a6 (1 β€ ai β€ 1000) β the lengths of the sides of the hexagons in centimeters in the clockwise order. It is guaranteed that the hexagon with the indicated properties and the exactly such sides exists.
Output
Print a single integer β the number of triangles with the sides of one 1 centimeter, into which the hexagon is split.
Examples
Input
1 1 1 1 1 1
Output
6
Input
1 2 1 2 1 2
Output
13
Note
This is what Gerald's hexagon looks like in the first sample:
<image>
And that's what it looks like in the second sample:
<image> | instruction | 0 | 40,018 | 23 | 80,036 |
Tags: brute force, geometry, math
Correct Solution:
```
a1, a2, a3, a4, a5, a6 = list(map(int, input().strip().split()))
ans = (a1+a2+a3)**2 - a1**2 - a3**2 - a5**2
print(ans)
``` | output | 1 | 40,018 | 23 | 80,037 |
Provide tags and a correct Python 3 solution for this coding contest problem.
Gerald got a very curious hexagon for his birthday. The boy found out that all the angles of the hexagon are equal to <image>. Then he measured the length of its sides, and found that each of them is equal to an integer number of centimeters. There the properties of the hexagon ended and Gerald decided to draw on it.
He painted a few lines, parallel to the sides of the hexagon. The lines split the hexagon into regular triangles with sides of 1 centimeter. Now Gerald wonders how many triangles he has got. But there were so many of them that Gerald lost the track of his counting. Help the boy count the triangles.
Input
The first and the single line of the input contains 6 space-separated integers a1, a2, a3, a4, a5 and a6 (1 β€ ai β€ 1000) β the lengths of the sides of the hexagons in centimeters in the clockwise order. It is guaranteed that the hexagon with the indicated properties and the exactly such sides exists.
Output
Print a single integer β the number of triangles with the sides of one 1 centimeter, into which the hexagon is split.
Examples
Input
1 1 1 1 1 1
Output
6
Input
1 2 1 2 1 2
Output
13
Note
This is what Gerald's hexagon looks like in the first sample:
<image>
And that's what it looks like in the second sample:
<image> | instruction | 0 | 40,019 | 23 | 80,038 |
Tags: brute force, geometry, math
Correct Solution:
```
j = input().split()
k = [int(i) for i in j]
print((k[0]+k[1]+k[2])**2-k[0]**2-k[2]**2-k[4]**2)
``` | output | 1 | 40,019 | 23 | 80,039 |
Provide tags and a correct Python 3 solution for this coding contest problem.
Gerald got a very curious hexagon for his birthday. The boy found out that all the angles of the hexagon are equal to <image>. Then he measured the length of its sides, and found that each of them is equal to an integer number of centimeters. There the properties of the hexagon ended and Gerald decided to draw on it.
He painted a few lines, parallel to the sides of the hexagon. The lines split the hexagon into regular triangles with sides of 1 centimeter. Now Gerald wonders how many triangles he has got. But there were so many of them that Gerald lost the track of his counting. Help the boy count the triangles.
Input
The first and the single line of the input contains 6 space-separated integers a1, a2, a3, a4, a5 and a6 (1 β€ ai β€ 1000) β the lengths of the sides of the hexagons in centimeters in the clockwise order. It is guaranteed that the hexagon with the indicated properties and the exactly such sides exists.
Output
Print a single integer β the number of triangles with the sides of one 1 centimeter, into which the hexagon is split.
Examples
Input
1 1 1 1 1 1
Output
6
Input
1 2 1 2 1 2
Output
13
Note
This is what Gerald's hexagon looks like in the first sample:
<image>
And that's what it looks like in the second sample:
<image> | instruction | 0 | 40,020 | 23 | 80,040 |
Tags: brute force, geometry, math
Correct Solution:
```
H = input().split()
H = [ int(x) for x in H ]
leftSum = 1
rightSum = 1
leftIndex = 1
rightIndex = 3
baseNum = H[ 2 ]
sum = 0
while( leftIndex >= 0 and rightIndex <= 4 ):
sum += ( baseNum * 2 ) - 1 + leftSum + rightSum
if( leftSum == 1 and rightSum == 1 ):
baseNum += 1
if( leftSum == 0 and rightSum == 0 ):
baseNum -= 1
H[ leftIndex ] -= 1
H[ rightIndex ] -= 1
if( H[ leftIndex ] == 0 ):
leftSum = 0
leftIndex -= 1
if( H[ rightIndex ] == 0 ):
rightSum = 0
rightIndex += 1
print( sum )
``` | output | 1 | 40,020 | 23 | 80,041 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
Gerald got a very curious hexagon for his birthday. The boy found out that all the angles of the hexagon are equal to <image>. Then he measured the length of its sides, and found that each of them is equal to an integer number of centimeters. There the properties of the hexagon ended and Gerald decided to draw on it.
He painted a few lines, parallel to the sides of the hexagon. The lines split the hexagon into regular triangles with sides of 1 centimeter. Now Gerald wonders how many triangles he has got. But there were so many of them that Gerald lost the track of his counting. Help the boy count the triangles.
Input
The first and the single line of the input contains 6 space-separated integers a1, a2, a3, a4, a5 and a6 (1 β€ ai β€ 1000) β the lengths of the sides of the hexagons in centimeters in the clockwise order. It is guaranteed that the hexagon with the indicated properties and the exactly such sides exists.
Output
Print a single integer β the number of triangles with the sides of one 1 centimeter, into which the hexagon is split.
Examples
Input
1 1 1 1 1 1
Output
6
Input
1 2 1 2 1 2
Output
13
Note
This is what Gerald's hexagon looks like in the first sample:
<image>
And that's what it looks like in the second sample:
<image>
Submitted Solution:
```
base, s1, height, _, _, s2 = map(int, input().split())
height += s1
at_level = 2 * base - 1
total = 0
for i in range(height):
if i < s1:
at_level += 1
elif i > s1:
at_level -= 1
if i < s2:
at_level += 1
elif i > s2:
at_level -= 1
total += at_level
print(total)
``` | instruction | 0 | 40,021 | 23 | 80,042 |
Yes | output | 1 | 40,021 | 23 | 80,043 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
Gerald got a very curious hexagon for his birthday. The boy found out that all the angles of the hexagon are equal to <image>. Then he measured the length of its sides, and found that each of them is equal to an integer number of centimeters. There the properties of the hexagon ended and Gerald decided to draw on it.
He painted a few lines, parallel to the sides of the hexagon. The lines split the hexagon into regular triangles with sides of 1 centimeter. Now Gerald wonders how many triangles he has got. But there were so many of them that Gerald lost the track of his counting. Help the boy count the triangles.
Input
The first and the single line of the input contains 6 space-separated integers a1, a2, a3, a4, a5 and a6 (1 β€ ai β€ 1000) β the lengths of the sides of the hexagons in centimeters in the clockwise order. It is guaranteed that the hexagon with the indicated properties and the exactly such sides exists.
Output
Print a single integer β the number of triangles with the sides of one 1 centimeter, into which the hexagon is split.
Examples
Input
1 1 1 1 1 1
Output
6
Input
1 2 1 2 1 2
Output
13
Note
This is what Gerald's hexagon looks like in the first sample:
<image>
And that's what it looks like in the second sample:
<image>
Submitted Solution:
```
import math as mt
import sys,string
input=sys.stdin.readline
#print=sys.stdout.write
#import random
from heapq import heappush,heapify,heappop
L=lambda : list(map(int,input().split()))
Ls=lambda : list(input().split())
M=lambda : map(int,input().split())
I=lambda :int(input())
def lcm(a,b):
return (a*b)//mt.gcd(a,b)
l=L()
print((l[-1]+l[0]+l[1])**2-l[1]**2-l[-1]**2-l[-3]**2)
``` | instruction | 0 | 40,022 | 23 | 80,044 |
Yes | output | 1 | 40,022 | 23 | 80,045 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
Gerald got a very curious hexagon for his birthday. The boy found out that all the angles of the hexagon are equal to <image>. Then he measured the length of its sides, and found that each of them is equal to an integer number of centimeters. There the properties of the hexagon ended and Gerald decided to draw on it.
He painted a few lines, parallel to the sides of the hexagon. The lines split the hexagon into regular triangles with sides of 1 centimeter. Now Gerald wonders how many triangles he has got. But there were so many of them that Gerald lost the track of his counting. Help the boy count the triangles.
Input
The first and the single line of the input contains 6 space-separated integers a1, a2, a3, a4, a5 and a6 (1 β€ ai β€ 1000) β the lengths of the sides of the hexagons in centimeters in the clockwise order. It is guaranteed that the hexagon with the indicated properties and the exactly such sides exists.
Output
Print a single integer β the number of triangles with the sides of one 1 centimeter, into which the hexagon is split.
Examples
Input
1 1 1 1 1 1
Output
6
Input
1 2 1 2 1 2
Output
13
Note
This is what Gerald's hexagon looks like in the first sample:
<image>
And that's what it looks like in the second sample:
<image>
Submitted Solution:
```
a,b,c,d,e,f=map(int,input().split());print((a+b+c)**2-a*a-c*c-e*e)
``` | instruction | 0 | 40,023 | 23 | 80,046 |
Yes | output | 1 | 40,023 | 23 | 80,047 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
Gerald got a very curious hexagon for his birthday. The boy found out that all the angles of the hexagon are equal to <image>. Then he measured the length of its sides, and found that each of them is equal to an integer number of centimeters. There the properties of the hexagon ended and Gerald decided to draw on it.
He painted a few lines, parallel to the sides of the hexagon. The lines split the hexagon into regular triangles with sides of 1 centimeter. Now Gerald wonders how many triangles he has got. But there were so many of them that Gerald lost the track of his counting. Help the boy count the triangles.
Input
The first and the single line of the input contains 6 space-separated integers a1, a2, a3, a4, a5 and a6 (1 β€ ai β€ 1000) β the lengths of the sides of the hexagons in centimeters in the clockwise order. It is guaranteed that the hexagon with the indicated properties and the exactly such sides exists.
Output
Print a single integer β the number of triangles with the sides of one 1 centimeter, into which the hexagon is split.
Examples
Input
1 1 1 1 1 1
Output
6
Input
1 2 1 2 1 2
Output
13
Note
This is what Gerald's hexagon looks like in the first sample:
<image>
And that's what it looks like in the second sample:
<image>
Submitted Solution:
```
ns = list(map(int, str.split(input())))
top = min(ns[1], ns[-1])
middle = max(ns[1], ns[-1]) - top
down = ns[1] + ns[2] - top - middle
triangles = (1 + ns[0] * 2 + top - 1) * top
triangles += middle * (ns[0] + top) * 2
triangles += (1 + ns[3] * 2 + down - 1) * down
print(triangles)
``` | instruction | 0 | 40,024 | 23 | 80,048 |
Yes | output | 1 | 40,024 | 23 | 80,049 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
Gerald got a very curious hexagon for his birthday. The boy found out that all the angles of the hexagon are equal to <image>. Then he measured the length of its sides, and found that each of them is equal to an integer number of centimeters. There the properties of the hexagon ended and Gerald decided to draw on it.
He painted a few lines, parallel to the sides of the hexagon. The lines split the hexagon into regular triangles with sides of 1 centimeter. Now Gerald wonders how many triangles he has got. But there were so many of them that Gerald lost the track of his counting. Help the boy count the triangles.
Input
The first and the single line of the input contains 6 space-separated integers a1, a2, a3, a4, a5 and a6 (1 β€ ai β€ 1000) β the lengths of the sides of the hexagons in centimeters in the clockwise order. It is guaranteed that the hexagon with the indicated properties and the exactly such sides exists.
Output
Print a single integer β the number of triangles with the sides of one 1 centimeter, into which the hexagon is split.
Examples
Input
1 1 1 1 1 1
Output
6
Input
1 2 1 2 1 2
Output
13
Note
This is what Gerald's hexagon looks like in the first sample:
<image>
And that's what it looks like in the second sample:
<image>
Submitted Solution:
```
__author__ = 'tka4a'
sides = list(map(int, input().split()))
if (sides[0] == sides[1]):
print((sides[0] ** 2) * 6)
else:
smin = min(sides[0], sides[1])
smax = max(sides[0], sides[1])
print((smin ** 2) * 3 + (smax ** 2 - (smax - smin) ** 2) * 3 + ((smax - smin) ** 2))
``` | instruction | 0 | 40,025 | 23 | 80,050 |
No | output | 1 | 40,025 | 23 | 80,051 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
Gerald got a very curious hexagon for his birthday. The boy found out that all the angles of the hexagon are equal to <image>. Then he measured the length of its sides, and found that each of them is equal to an integer number of centimeters. There the properties of the hexagon ended and Gerald decided to draw on it.
He painted a few lines, parallel to the sides of the hexagon. The lines split the hexagon into regular triangles with sides of 1 centimeter. Now Gerald wonders how many triangles he has got. But there were so many of them that Gerald lost the track of his counting. Help the boy count the triangles.
Input
The first and the single line of the input contains 6 space-separated integers a1, a2, a3, a4, a5 and a6 (1 β€ ai β€ 1000) β the lengths of the sides of the hexagons in centimeters in the clockwise order. It is guaranteed that the hexagon with the indicated properties and the exactly such sides exists.
Output
Print a single integer β the number of triangles with the sides of one 1 centimeter, into which the hexagon is split.
Examples
Input
1 1 1 1 1 1
Output
6
Input
1 2 1 2 1 2
Output
13
Note
This is what Gerald's hexagon looks like in the first sample:
<image>
And that's what it looks like in the second sample:
<image>
Submitted Solution:
```
a = sorted(list(map(int, input().split())))
if a[2] != a[3]:
print(a[0] ** 2 + 4 * a[0] * a[-1] + a[-1] ** 2)
elif a[1] != a[2]:
print(4 * a[0] * a[-1] + 2 * a[-1] ** 2)
else:
print(4 * a[0] * a[-1] + 2 * a[0] ** 2)
``` | instruction | 0 | 40,026 | 23 | 80,052 |
No | output | 1 | 40,026 | 23 | 80,053 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
Gerald got a very curious hexagon for his birthday. The boy found out that all the angles of the hexagon are equal to <image>. Then he measured the length of its sides, and found that each of them is equal to an integer number of centimeters. There the properties of the hexagon ended and Gerald decided to draw on it.
He painted a few lines, parallel to the sides of the hexagon. The lines split the hexagon into regular triangles with sides of 1 centimeter. Now Gerald wonders how many triangles he has got. But there were so many of them that Gerald lost the track of his counting. Help the boy count the triangles.
Input
The first and the single line of the input contains 6 space-separated integers a1, a2, a3, a4, a5 and a6 (1 β€ ai β€ 1000) β the lengths of the sides of the hexagons in centimeters in the clockwise order. It is guaranteed that the hexagon with the indicated properties and the exactly such sides exists.
Output
Print a single integer β the number of triangles with the sides of one 1 centimeter, into which the hexagon is split.
Examples
Input
1 1 1 1 1 1
Output
6
Input
1 2 1 2 1 2
Output
13
Note
This is what Gerald's hexagon looks like in the first sample:
<image>
And that's what it looks like in the second sample:
<image>
Submitted Solution:
```
a_1, a_2, a_3, a_4, a_5, a_6 = map(int, input().split())
print((a_1 + a_2 + a_3) ** 2 - a_1 ** 2 - a_2 ** 2 - a_5 ** 2)
``` | instruction | 0 | 40,027 | 23 | 80,054 |
No | output | 1 | 40,027 | 23 | 80,055 |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.