message stringlengths 2 45.8k | message_type stringclasses 2 values | message_id int64 0 1 | conversation_id int64 254 108k | cluster float64 3 3 | __index_level_0__ int64 508 217k |
|---|---|---|---|---|---|
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
Polycarp takes part in a quadcopter competition. According to the rules a flying robot should:
* start the race from some point of a field,
* go around the flag,
* close cycle returning back to the starting point.
Polycarp knows the coordinates of the starting point (x1, y1) and the coordinates of the point where the flag is situated (x2, y2). Polycarp’s quadcopter can fly only parallel to the sides of the field each tick changing exactly one coordinate by 1. It means that in one tick the quadcopter can fly from the point (x, y) to any of four points: (x - 1, y), (x + 1, y), (x, y - 1) or (x, y + 1).
Thus the quadcopter path is a closed cycle starting and finishing in (x1, y1) and containing the point (x2, y2) strictly inside.
<image> The picture corresponds to the first example: the starting (and finishing) point is in (1, 5) and the flag is in (5, 2).
What is the minimal length of the quadcopter path?
Input
The first line contains two integer numbers x1 and y1 ( - 100 ≤ x1, y1 ≤ 100) — coordinates of the quadcopter starting (and finishing) point.
The second line contains two integer numbers x2 and y2 ( - 100 ≤ x2, y2 ≤ 100) — coordinates of the flag.
It is guaranteed that the quadcopter starting point and the flag do not coincide.
Output
Print the length of minimal path of the quadcopter to surround the flag and return back.
Examples
Input
1 5
5 2
Output
18
Input
0 1
0 0
Output
8
Submitted Solution:
```
line1 = input()
line2 = input()
dc = [int(s) for s in line1.split(' ')]
fc = [int(s) for s in line2.split(' ')]
d = [abs(a - b) for a, b in zip(dc, fc)]
print(d)
transit_x = max(2, d[0]+1)*2
transit_y = max(2, d[1]+1)*2
t = transit_x + transit_y
print(t)
``` | instruction | 0 | 70,432 | 3 | 140,864 |
No | output | 1 | 70,432 | 3 | 140,865 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
Polycarp takes part in a quadcopter competition. According to the rules a flying robot should:
* start the race from some point of a field,
* go around the flag,
* close cycle returning back to the starting point.
Polycarp knows the coordinates of the starting point (x1, y1) and the coordinates of the point where the flag is situated (x2, y2). Polycarp’s quadcopter can fly only parallel to the sides of the field each tick changing exactly one coordinate by 1. It means that in one tick the quadcopter can fly from the point (x, y) to any of four points: (x - 1, y), (x + 1, y), (x, y - 1) or (x, y + 1).
Thus the quadcopter path is a closed cycle starting and finishing in (x1, y1) and containing the point (x2, y2) strictly inside.
<image> The picture corresponds to the first example: the starting (and finishing) point is in (1, 5) and the flag is in (5, 2).
What is the minimal length of the quadcopter path?
Input
The first line contains two integer numbers x1 and y1 ( - 100 ≤ x1, y1 ≤ 100) — coordinates of the quadcopter starting (and finishing) point.
The second line contains two integer numbers x2 and y2 ( - 100 ≤ x2, y2 ≤ 100) — coordinates of the flag.
It is guaranteed that the quadcopter starting point and the flag do not coincide.
Output
Print the length of minimal path of the quadcopter to surround the flag and return back.
Examples
Input
1 5
5 2
Output
18
Input
0 1
0 0
Output
8
Submitted Solution:
```
a, b = map(int, input().split())
c, d = map(int, input().split())
print(abs(a - c) * 2 + abs(b - d) * 2 + 4)
``` | instruction | 0 | 70,433 | 3 | 140,866 |
No | output | 1 | 70,433 | 3 | 140,867 |
Provide tags and a correct Python 3 solution for this coding contest problem.
The stardate is 1983, and Princess Heidi is getting better at detecting the Death Stars. This time, two Rebel spies have yet again given Heidi two maps with the possible locations of the Death Star. Since she got rid of all double agents last time, she knows that both maps are correct, and indeed show the map of the solar system that contains the Death Star. However, this time the Empire has hidden the Death Star very well, and Heidi needs to find a place that appears on both maps in order to detect the Death Star.
The first map is an N × M grid, each cell of which shows some type of cosmic object that is present in the corresponding quadrant of space. The second map is an M × N grid. Heidi needs to align those two maps in such a way that they overlap over some M × M section in which all cosmic objects are identical. Help Heidi by identifying where such an M × M section lies within both maps.
Input
The first line of the input contains two space-separated integers N and M (1 ≤ N ≤ 2000, 1 ≤ M ≤ 200, M ≤ N). The next N lines each contain M lower-case Latin characters (a-z), denoting the first map. Different characters correspond to different cosmic object types. The next M lines each contain N characters, describing the second map in the same format.
Output
The only line of the output should contain two space-separated integers i and j, denoting that the section of size M × M in the first map that starts at the i-th row is equal to the section of the second map that starts at the j-th column. Rows and columns are numbered starting from 1.
If there are several possible ways to align the maps, Heidi will be satisfied with any of those. It is guaranteed that a solution exists.
Example
Input
10 5
somer
andom
noise
mayth
eforc
ebewi
thyou
hctwo
again
noise
somermayth
andomeforc
noiseebewi
againthyou
noisehctwo
Output
4 6
Note
The 5-by-5 grid for the first test case looks like this:
mayth
eforc
ebewi
thyou
hctwo
| instruction | 0 | 70,466 | 3 | 140,932 |
Tags: hashing, strings
Correct Solution:
```
n,m=list(map(int,input().split()))
s=[]
h=[]
mod=10**9
mod+=7
for i in range(n):
s=(input())
s=s.lower()
hw=0
for i in range(m):
hw+=ord(s[i])*(10**(m-i))
h.append(hw%mod)
h1=[[] for i in range(n-m+1)]
for i in range(m):
hw=0
s=input()
s=s.lower()
aux=[]
for i in range(m):
hw+=ord(s[i])*(10**(m-i))
hw%=mod
h1[0].append(hw)
yy=1
for i in range(m,n):
hw-=(ord(s[i-m])*(10**(m)))
hw*=10
hw+=(ord(s[i])*(10))
hw%=mod
h1[yy].append(hw)
yy+=1
t=False
y=0
for i in range(len(h1)):
x=0
while x<n-m+1:
if h1[i][0]==h[x]:
y=0
ans=[x+1,i+1]
while y<m and h1[i][y]==h[x]:
x+=1
y+=1
else:
x+=1
if y==m:
break
if y==m:
break
print(ans[0],ans[1])
``` | output | 1 | 70,466 | 3 | 140,933 |
Provide tags and a correct Python 3 solution for this coding contest problem.
The stardate is 1983, and Princess Heidi is getting better at detecting the Death Stars. This time, two Rebel spies have yet again given Heidi two maps with the possible locations of the Death Star. Since she got rid of all double agents last time, she knows that both maps are correct, and indeed show the map of the solar system that contains the Death Star. However, this time the Empire has hidden the Death Star very well, and Heidi needs to find a place that appears on both maps in order to detect the Death Star.
The first map is an N × M grid, each cell of which shows some type of cosmic object that is present in the corresponding quadrant of space. The second map is an M × N grid. Heidi needs to align those two maps in such a way that they overlap over some M × M section in which all cosmic objects are identical. Help Heidi by identifying where such an M × M section lies within both maps.
Input
The first line of the input contains two space-separated integers N and M (1 ≤ N ≤ 2000, 1 ≤ M ≤ 200, M ≤ N). The next N lines each contain M lower-case Latin characters (a-z), denoting the first map. Different characters correspond to different cosmic object types. The next M lines each contain N characters, describing the second map in the same format.
Output
The only line of the output should contain two space-separated integers i and j, denoting that the section of size M × M in the first map that starts at the i-th row is equal to the section of the second map that starts at the j-th column. Rows and columns are numbered starting from 1.
If there are several possible ways to align the maps, Heidi will be satisfied with any of those. It is guaranteed that a solution exists.
Example
Input
10 5
somer
andom
noise
mayth
eforc
ebewi
thyou
hctwo
again
noise
somermayth
andomeforc
noiseebewi
againthyou
noisehctwo
Output
4 6
Note
The 5-by-5 grid for the first test case looks like this:
mayth
eforc
ebewi
thyou
hctwo
| instruction | 0 | 70,467 | 3 | 140,934 |
Tags: hashing, strings
Correct Solution:
```
n, m = list(map(int, input().strip().split(' ')))
mat1, mat2 = [], []
for i in range(0, n): mat1.append(tuple(input().strip()))
for i in range(0, m): mat2.append(tuple(input().strip()))
ix, jx, flg = -1, -1, 0
matr, matc = [], []
for i in range(0, n-m+1):
si, se = i, i+m
matr.append(hash(tuple(mat1[si:se])))
matcur2 = []
for c2i in range(0, m): matcur2.append(tuple(mat2[c2i][si:se]))
matc.append(hash(tuple(matcur2)))
nx = len(matr)
ix, jx = -1, -1
for ix in range(0, nx):
flg=0
for jx in range(0, nx):
if matr[ix]==matc[jx]:
flg=1
break
if flg==1: break
print(str(ix+1)+" "+str(jx+1))
``` | output | 1 | 70,467 | 3 | 140,935 |
Provide tags and a correct Python 3 solution for this coding contest problem.
The stardate is 1983, and Princess Heidi is getting better at detecting the Death Stars. This time, two Rebel spies have yet again given Heidi two maps with the possible locations of the Death Star. Since she got rid of all double agents last time, she knows that both maps are correct, and indeed show the map of the solar system that contains the Death Star. However, this time the Empire has hidden the Death Star very well, and Heidi needs to find a place that appears on both maps in order to detect the Death Star.
The first map is an N × M grid, each cell of which shows some type of cosmic object that is present in the corresponding quadrant of space. The second map is an M × N grid. Heidi needs to align those two maps in such a way that they overlap over some M × M section in which all cosmic objects are identical. Help Heidi by identifying where such an M × M section lies within both maps.
Input
The first line of the input contains two space-separated integers N and M (1 ≤ N ≤ 2000, 1 ≤ M ≤ 200, M ≤ N). The next N lines each contain M lower-case Latin characters (a-z), denoting the first map. Different characters correspond to different cosmic object types. The next M lines each contain N characters, describing the second map in the same format.
Output
The only line of the output should contain two space-separated integers i and j, denoting that the section of size M × M in the first map that starts at the i-th row is equal to the section of the second map that starts at the j-th column. Rows and columns are numbered starting from 1.
If there are several possible ways to align the maps, Heidi will be satisfied with any of those. It is guaranteed that a solution exists.
Example
Input
10 5
somer
andom
noise
mayth
eforc
ebewi
thyou
hctwo
again
noise
somermayth
andomeforc
noiseebewi
againthyou
noisehctwo
Output
4 6
Note
The 5-by-5 grid for the first test case looks like this:
mayth
eforc
ebewi
thyou
hctwo
| instruction | 0 | 70,468 | 3 | 140,936 |
Tags: hashing, strings
Correct Solution:
```
n, m = list(map(int, input().strip().split(' ')))
L, M = [], []
for i in range(n):
L.append(tuple(input().strip()))
for i in range(0, m):
M.append(tuple(input().strip()))
k=0
row, col = [], []
for i in range(n-m+1):
init, end = i, i+m
row.append(hash(tuple(L[init:end])))
D = []
for j in range(0, m):
D.append(tuple(M[j][init:end]))
col.append(hash(tuple(D)))
for ix in range(len(row)):
k=0
for jx in range(len(row)):
if row[ix]==col[jx]:
k=1
break
if k==1:
break
print(ix+1,end=' ')
print(jx+1)
``` | output | 1 | 70,468 | 3 | 140,937 |
Provide tags and a correct Python 3 solution for this coding contest problem.
The stardate is 1983, and Princess Heidi is getting better at detecting the Death Stars. This time, two Rebel spies have yet again given Heidi two maps with the possible locations of the Death Star. Since she got rid of all double agents last time, she knows that both maps are correct, and indeed show the map of the solar system that contains the Death Star. However, this time the Empire has hidden the Death Star very well, and Heidi needs to find a place that appears on both maps in order to detect the Death Star.
The first map is an N × M grid, each cell of which shows some type of cosmic object that is present in the corresponding quadrant of space. The second map is an M × N grid. Heidi needs to align those two maps in such a way that they overlap over some M × M section in which all cosmic objects are identical. Help Heidi by identifying where such an M × M section lies within both maps.
Input
The first line of the input contains two space-separated integers N and M (1 ≤ N ≤ 2000, 1 ≤ M ≤ 200, M ≤ N). The next N lines each contain M lower-case Latin characters (a-z), denoting the first map. Different characters correspond to different cosmic object types. The next M lines each contain N characters, describing the second map in the same format.
Output
The only line of the output should contain two space-separated integers i and j, denoting that the section of size M × M in the first map that starts at the i-th row is equal to the section of the second map that starts at the j-th column. Rows and columns are numbered starting from 1.
If there are several possible ways to align the maps, Heidi will be satisfied with any of those. It is guaranteed that a solution exists.
Example
Input
10 5
somer
andom
noise
mayth
eforc
ebewi
thyou
hctwo
again
noise
somermayth
andomeforc
noiseebewi
againthyou
noisehctwo
Output
4 6
Note
The 5-by-5 grid for the first test case looks like this:
mayth
eforc
ebewi
thyou
hctwo
| instruction | 0 | 70,469 | 3 | 140,938 |
Tags: hashing, strings
Correct Solution:
```
n, m = [int(x) for x in input().split()]
list1 = []
list2 = []
for i in range(n):
list1.append(input())
for j in range(m):
list2.append(input())
list3 = []
for i in range(n - m + 1):
y = ""
for j in range(m):
y += list1[j + i]
list3.append(y)
list4 = []
for i in range(n - m + 1):
y = ""
for j in range(m):
y += list2[j][i:i + m]
list4.append(y)
for i in list3:
if i in list4:
exit(print(list3.index(i) + 1, list4.index(i) + 1))
``` | output | 1 | 70,469 | 3 | 140,939 |
Provide tags and a correct Python 3 solution for this coding contest problem.
The stardate is 1983, and Princess Heidi is getting better at detecting the Death Stars. This time, two Rebel spies have yet again given Heidi two maps with the possible locations of the Death Star. Since she got rid of all double agents last time, she knows that both maps are correct, and indeed show the map of the solar system that contains the Death Star. However, this time the Empire has hidden the Death Star very well, and Heidi needs to find a place that appears on both maps in order to detect the Death Star.
The first map is an N × M grid, each cell of which shows some type of cosmic object that is present in the corresponding quadrant of space. The second map is an M × N grid. Heidi needs to align those two maps in such a way that they overlap over some M × M section in which all cosmic objects are identical. Help Heidi by identifying where such an M × M section lies within both maps.
Input
The first line of the input contains two space-separated integers N and M (1 ≤ N ≤ 2000, 1 ≤ M ≤ 200, M ≤ N). The next N lines each contain M lower-case Latin characters (a-z), denoting the first map. Different characters correspond to different cosmic object types. The next M lines each contain N characters, describing the second map in the same format.
Output
The only line of the output should contain two space-separated integers i and j, denoting that the section of size M × M in the first map that starts at the i-th row is equal to the section of the second map that starts at the j-th column. Rows and columns are numbered starting from 1.
If there are several possible ways to align the maps, Heidi will be satisfied with any of those. It is guaranteed that a solution exists.
Example
Input
10 5
somer
andom
noise
mayth
eforc
ebewi
thyou
hctwo
again
noise
somermayth
andomeforc
noiseebewi
againthyou
noisehctwo
Output
4 6
Note
The 5-by-5 grid for the first test case looks like this:
mayth
eforc
ebewi
thyou
hctwo
| instruction | 0 | 70,470 | 3 | 140,940 |
Tags: hashing, strings
Correct Solution:
```
n, m = [int(x) for x in input().split()]
list1 = []
list2 = []
for i in range(n):
list1.append(input())
for j in range(m):
list2.append(input())
list3 = []
for i in range(n - m + 1):
y = ""
for j in range(m):
y += list1[j + i]
list3.append(y)
list4 = []
for i in range(n - m + 1):
y = ""
for j in range(m):
y += list2[j][i:i + m]
list4.append(y)
for i in list3:
if i in list4:
print(list3.index(i) + 1, list4.index(i) + 1)
quit()
``` | output | 1 | 70,470 | 3 | 140,941 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
The stardate is 1983, and Princess Heidi is getting better at detecting the Death Stars. This time, two Rebel spies have yet again given Heidi two maps with the possible locations of the Death Star. Since she got rid of all double agents last time, she knows that both maps are correct, and indeed show the map of the solar system that contains the Death Star. However, this time the Empire has hidden the Death Star very well, and Heidi needs to find a place that appears on both maps in order to detect the Death Star.
The first map is an N × M grid, each cell of which shows some type of cosmic object that is present in the corresponding quadrant of space. The second map is an M × N grid. Heidi needs to align those two maps in such a way that they overlap over some M × M section in which all cosmic objects are identical. Help Heidi by identifying where such an M × M section lies within both maps.
Input
The first line of the input contains two space-separated integers N and M (1 ≤ N ≤ 2000, 1 ≤ M ≤ 200, M ≤ N). The next N lines each contain M lower-case Latin characters (a-z), denoting the first map. Different characters correspond to different cosmic object types. The next M lines each contain N characters, describing the second map in the same format.
Output
The only line of the output should contain two space-separated integers i and j, denoting that the section of size M × M in the first map that starts at the i-th row is equal to the section of the second map that starts at the j-th column. Rows and columns are numbered starting from 1.
If there are several possible ways to align the maps, Heidi will be satisfied with any of those. It is guaranteed that a solution exists.
Example
Input
10 5
somer
andom
noise
mayth
eforc
ebewi
thyou
hctwo
again
noise
somermayth
andomeforc
noiseebewi
againthyou
noisehctwo
Output
4 6
Note
The 5-by-5 grid for the first test case looks like this:
mayth
eforc
ebewi
thyou
hctwo
Submitted Solution:
```
n,m=map(int,input().split())
nm=[];mn=[]
for i in range(n):
nm.append(input())
for j in range(m):
mn.append(input())
a={}
for j in range(n-m+1):
for k in range(m):
a[mn[k][j:j+m]]=a.get(mn[k][j:j+m],[])
a[mn[k][j:j+m]].append(j+1)
for i in range(n-m):
try:r=a[nm[i]];cnt=1
except:continue
for j in range(1,m):
try:
r=list(set(a[nm[i+j]]).intersection(r));cnt+=1
except:break
if len(r)>=1 and cnt==m:
exit(print(i+1,r[0]))
if n==m==200:
print(1,1)
``` | instruction | 0 | 70,471 | 3 | 140,942 |
No | output | 1 | 70,471 | 3 | 140,943 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
The stardate is 1983, and Princess Heidi is getting better at detecting the Death Stars. This time, two Rebel spies have yet again given Heidi two maps with the possible locations of the Death Star. Since she got rid of all double agents last time, she knows that both maps are correct, and indeed show the map of the solar system that contains the Death Star. However, this time the Empire has hidden the Death Star very well, and Heidi needs to find a place that appears on both maps in order to detect the Death Star.
The first map is an N × M grid, each cell of which shows some type of cosmic object that is present in the corresponding quadrant of space. The second map is an M × N grid. Heidi needs to align those two maps in such a way that they overlap over some M × M section in which all cosmic objects are identical. Help Heidi by identifying where such an M × M section lies within both maps.
Input
The first line of the input contains two space-separated integers N and M (1 ≤ N ≤ 2000, 1 ≤ M ≤ 200, M ≤ N). The next N lines each contain M lower-case Latin characters (a-z), denoting the first map. Different characters correspond to different cosmic object types. The next M lines each contain N characters, describing the second map in the same format.
Output
The only line of the output should contain two space-separated integers i and j, denoting that the section of size M × M in the first map that starts at the i-th row is equal to the section of the second map that starts at the j-th column. Rows and columns are numbered starting from 1.
If there are several possible ways to align the maps, Heidi will be satisfied with any of those. It is guaranteed that a solution exists.
Example
Input
10 5
somer
andom
noise
mayth
eforc
ebewi
thyou
hctwo
again
noise
somermayth
andomeforc
noiseebewi
againthyou
noisehctwo
Output
4 6
Note
The 5-by-5 grid for the first test case looks like this:
mayth
eforc
ebewi
thyou
hctwo
Submitted Solution:
```
n,m=map(int,input().strip().split(' '))
Dicti={}
M=[]
DP=[]
for i in range(m):
DP.append([[0]]*n)
for i in range(n):
s=input()
if s in Dicti:
Dicti[s].append(i+1)
else:
Dicti[s]=[i+1]
for i in range(m):
M.append(input())
for i in range(m):
j=0
while j+m<=n :
a=M[i][j:j+m]
if a in Dicti:
DP[i][j]=Dicti[a]
else :
DP[i][j]=[-5]
j=j+1
for i in range(n):
j=1
d=DP[0][i][0]
e=True
while j<m and e==True:
e=False
for k in range(len(DP[j][i])):
if DP[j][i][k]==d+1:
d=DP[j][i][k]
e=True
break
j=j+1
if j==m:
print(d-m+1,end=' ')
print(i+1)
``` | instruction | 0 | 70,472 | 3 | 140,944 |
No | output | 1 | 70,472 | 3 | 140,945 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
The stardate is 1983, and Princess Heidi is getting better at detecting the Death Stars. This time, two Rebel spies have yet again given Heidi two maps with the possible locations of the Death Star. Since she got rid of all double agents last time, she knows that both maps are correct, and indeed show the map of the solar system that contains the Death Star. However, this time the Empire has hidden the Death Star very well, and Heidi needs to find a place that appears on both maps in order to detect the Death Star.
The first map is an N × M grid, each cell of which shows some type of cosmic object that is present in the corresponding quadrant of space. The second map is an M × N grid. Heidi needs to align those two maps in such a way that they overlap over some M × M section in which all cosmic objects are identical. Help Heidi by identifying where such an M × M section lies within both maps.
Input
The first line of the input contains two space-separated integers N and M (1 ≤ N ≤ 2000, 1 ≤ M ≤ 200, M ≤ N). The next N lines each contain M lower-case Latin characters (a-z), denoting the first map. Different characters correspond to different cosmic object types. The next M lines each contain N characters, describing the second map in the same format.
Output
The only line of the output should contain two space-separated integers i and j, denoting that the section of size M × M in the first map that starts at the i-th row is equal to the section of the second map that starts at the j-th column. Rows and columns are numbered starting from 1.
If there are several possible ways to align the maps, Heidi will be satisfied with any of those. It is guaranteed that a solution exists.
Example
Input
10 5
somer
andom
noise
mayth
eforc
ebewi
thyou
hctwo
again
noise
somermayth
andomeforc
noiseebewi
againthyou
noisehctwo
Output
4 6
Note
The 5-by-5 grid for the first test case looks like this:
mayth
eforc
ebewi
thyou
hctwo
Submitted Solution:
```
n,m=map(int,input().strip().split(' '))
Dicti={}
M=[]
DP=[]
for i in range(m):
DP.append([0]*n)
for i in range(n):
Dicti[input()]=i+1
for i in range(m):
M.append(input())
for i in range(m):
j=0
k=0
while j!=n:
a=M[i][j:j+m]
if a in Dicti:
DP[i][j]=Dicti[a]
else :
DP[i][j]=-5
j=j+1
for i in range(n):
j=1
d=DP[0][i]
while j<m and DP[j][i]==d+1:
d=DP[j][i]
j=j+1
if j==m:
print(DP[0][i],end=' ')
print(i+1)
``` | instruction | 0 | 70,473 | 3 | 140,946 |
No | output | 1 | 70,473 | 3 | 140,947 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
The stardate is 1983, and Princess Heidi is getting better at detecting the Death Stars. This time, two Rebel spies have yet again given Heidi two maps with the possible locations of the Death Star. Since she got rid of all double agents last time, she knows that both maps are correct, and indeed show the map of the solar system that contains the Death Star. However, this time the Empire has hidden the Death Star very well, and Heidi needs to find a place that appears on both maps in order to detect the Death Star.
The first map is an N × M grid, each cell of which shows some type of cosmic object that is present in the corresponding quadrant of space. The second map is an M × N grid. Heidi needs to align those two maps in such a way that they overlap over some M × M section in which all cosmic objects are identical. Help Heidi by identifying where such an M × M section lies within both maps.
Input
The first line of the input contains two space-separated integers N and M (1 ≤ N ≤ 2000, 1 ≤ M ≤ 200, M ≤ N). The next N lines each contain M lower-case Latin characters (a-z), denoting the first map. Different characters correspond to different cosmic object types. The next M lines each contain N characters, describing the second map in the same format.
Output
The only line of the output should contain two space-separated integers i and j, denoting that the section of size M × M in the first map that starts at the i-th row is equal to the section of the second map that starts at the j-th column. Rows and columns are numbered starting from 1.
If there are several possible ways to align the maps, Heidi will be satisfied with any of those. It is guaranteed that a solution exists.
Example
Input
10 5
somer
andom
noise
mayth
eforc
ebewi
thyou
hctwo
again
noise
somermayth
andomeforc
noiseebewi
againthyou
noisehctwo
Output
4 6
Note
The 5-by-5 grid for the first test case looks like this:
mayth
eforc
ebewi
thyou
hctwo
Submitted Solution:
```
N, M = input().split(' ')
N = int(N)
M = int(M)
matrix_1 = []
matrix_2 = []
for i in range(N):
matrix_1.append(input())
for i in range(M):
matrix_2.append(input())
def find(word):
if word in matrix_2[0]:
return matrix_2[0].index(word)
return False
def go():
for i in range(N-M+1):
x = find(matrix_1[i])
if x is not False:
found = True
for j in range(1, M):
if matrix_2[j][x:x+M] != matrix_1[i + j]:
found = False
break
if found:
return '{} {}'.format(i + 1, x + 1)
print(go())
``` | instruction | 0 | 70,474 | 3 | 140,948 |
No | output | 1 | 70,474 | 3 | 140,949 |
Provide a correct Python 3 solution for this coding contest problem.
Anchored Balloon
A balloon placed on the ground is connected to one or more anchors on the ground with ropes. Each rope is long enough to connect the balloon and the anchor. No two ropes cross each other. Figure E-1 shows such a situation.
<image>
Figure E-1: A balloon and ropes on the ground
Now the balloon takes off, and your task is to find how high the balloon can go up with keeping the rope connections. The positions of the anchors are fixed. The lengths of the ropes and the positions of the anchors are given. You may assume that these ropes have no weight and thus can be straightened up when pulled to whichever directions. Figure E-2 shows the highest position of the balloon for the situation shown in Figure E-1.
<image>
Figure E-2: The highest position of the balloon
Input
The input consists of multiple datasets, each in the following format.
> n
> x1 y1 l1
> ...
> xn yn ln
>
The first line of a dataset contains an integer n (1 ≤ n ≤ 10) representing the number of the ropes. Each of the following n lines contains three integers, xi, yi, and li, separated by a single space. Pi = (xi, yi) represents the position of the anchor connecting the i-th rope, and li represents the length of the rope. You can assume that −100 ≤ xi ≤ 100, −100 ≤ yi ≤ 100, and 1 ≤ li ≤ 300. The balloon is initially placed at (0, 0) on the ground. You can ignore the size of the balloon and the anchors.
You can assume that Pi and Pj represent different positions if i ≠ j. You can also assume that the distance between Pi and (0, 0) is less than or equal to li−1. This means that the balloon can go up at least 1 unit high.
Figures E-1 and E-2 correspond to the first dataset of Sample Input below.
The end of the input is indicated by a line containing a zero.
Output
For each dataset, output a single line containing the maximum height that the balloon can go up. The error of the value should be no greater than 0.00001. No extra characters should appear in the output.
Sample Input
3
10 10 20
10 -10 20
-10 10 120
1
10 10 16
2
10 10 20
10 -10 20
2
100 0 101
-90 0 91
2
0 0 53
30 40 102
3
10 10 20
10 -10 20
-10 -10 20
3
1 5 13
5 -3 13
-3 -3 13
3
98 97 168
-82 -80 193
-99 -96 211
4
90 -100 160
-80 -80 150
90 80 150
80 80 245
4
85 -90 290
-80 -80 220
-85 90 145
85 90 170
5
0 0 4
3 0 5
-3 0 5
0 3 5
0 -3 5
10
95 -93 260
-86 96 211
91 90 177
-81 -80 124
-91 91 144
97 94 165
-90 -86 194
89 85 167
-93 -80 222
92 -84 218
0
Output for the Sample Input
17.3205081
16.0000000
17.3205081
13.8011200
53.0000000
14.1421356
12.0000000
128.3928757
94.1879092
131.1240816
4.0000000
72.2251798
Example
Input
3
10 10 20
10 -10 20
-10 10 120
1
10 10 16
2
10 10 20
10 -10 20
2
100 0 101
-90 0 91
2
0 0 53
30 40 102
3
10 10 20
10 -10 20
-10 -10 20
3
1 5 13
5 -3 13
-3 -3 13
3
98 97 168
-82 -80 193
-99 -96 211
4
90 -100 160
-80 -80 150
90 80 150
80 80 245
4
85 -90 290
-80 -80 220
-85 90 145
85 90 170
5
0 0 4
3 0 5
-3 0 5
0 3 5
0 -3 5
10
95 -93 260
-86 96 211
91 90 177
-81 -80 124
-91 91 144
97 94 165
-90 -86 194
89 85 167
-93 -80 222
92 -84 218
0
Output
17.3205081
16.0000000
17.3205081
13.8011200
53.0000000
14.1421356
12.0000000
128.3928757
94.1879092
131.1240816
4.0000000
72.2251798 | instruction | 0 | 70,691 | 3 | 141,382 |
"Correct Solution:
```
import math,string,itertools,fractions,heapq,collections,re,array,bisect,sys,random,time,copy,functools
sys.setrecursionlimit(10**7)
inf = 10**20
eps = 1.0 / 10**13
mod = 10**9+7
dd = [(-1,0),(0,1),(1,0),(0,-1)]
ddn = [(-1,0),(-1,1),(0,1),(1,1),(1,0),(1,-1),(0,-1),(-1,-1)]
def LI(): return [int(x) for x in sys.stdin.readline().split()]
def LI_(): return [int(x)-1 for x in sys.stdin.readline().split()]
def LF(): return [float(x) for x in sys.stdin.readline().split()]
def LS(): return sys.stdin.readline().split()
def I(): return int(sys.stdin.readline())
def F(): return float(sys.stdin.readline())
def S(): return input()
def pf(s): return print(s, flush=True)
eps = 1e-7
def bs(f, mi, ma):
mm = -1
while ma > mi + eps:
m1 = (mi*2+ma) / 3.0
m2 = (mi+ma*2) / 3.0
r1 = f(m1)
r2 = f(m2)
if r1 < r2:
mi = m1
else:
ma = m2
return f((ma+mi)/2.0)
def main():
rr = []
def f(n):
a = [LI() for _ in range(n)]
def _f(x,y):
r = inf
for px,py,l in a:
r = min(r, l**2 - (x-px)**2 - (y-py)**2)
return r
def _fy(y):
def _ff(x):
return _f(x,y)
return bs(_ff, -100, 100)
r = bs(_fy,-100,100)
return "{:0.7f}".format(r**0.5)
while 1:
n = I()
if n == 0:
break
rr.append(f(n))
return '\n'.join(map(str,rr))
print(main())
``` | output | 1 | 70,691 | 3 | 141,383 |
Provide a correct Python 3 solution for this coding contest problem.
Anchored Balloon
A balloon placed on the ground is connected to one or more anchors on the ground with ropes. Each rope is long enough to connect the balloon and the anchor. No two ropes cross each other. Figure E-1 shows such a situation.
<image>
Figure E-1: A balloon and ropes on the ground
Now the balloon takes off, and your task is to find how high the balloon can go up with keeping the rope connections. The positions of the anchors are fixed. The lengths of the ropes and the positions of the anchors are given. You may assume that these ropes have no weight and thus can be straightened up when pulled to whichever directions. Figure E-2 shows the highest position of the balloon for the situation shown in Figure E-1.
<image>
Figure E-2: The highest position of the balloon
Input
The input consists of multiple datasets, each in the following format.
> n
> x1 y1 l1
> ...
> xn yn ln
>
The first line of a dataset contains an integer n (1 ≤ n ≤ 10) representing the number of the ropes. Each of the following n lines contains three integers, xi, yi, and li, separated by a single space. Pi = (xi, yi) represents the position of the anchor connecting the i-th rope, and li represents the length of the rope. You can assume that −100 ≤ xi ≤ 100, −100 ≤ yi ≤ 100, and 1 ≤ li ≤ 300. The balloon is initially placed at (0, 0) on the ground. You can ignore the size of the balloon and the anchors.
You can assume that Pi and Pj represent different positions if i ≠ j. You can also assume that the distance between Pi and (0, 0) is less than or equal to li−1. This means that the balloon can go up at least 1 unit high.
Figures E-1 and E-2 correspond to the first dataset of Sample Input below.
The end of the input is indicated by a line containing a zero.
Output
For each dataset, output a single line containing the maximum height that the balloon can go up. The error of the value should be no greater than 0.00001. No extra characters should appear in the output.
Sample Input
3
10 10 20
10 -10 20
-10 10 120
1
10 10 16
2
10 10 20
10 -10 20
2
100 0 101
-90 0 91
2
0 0 53
30 40 102
3
10 10 20
10 -10 20
-10 -10 20
3
1 5 13
5 -3 13
-3 -3 13
3
98 97 168
-82 -80 193
-99 -96 211
4
90 -100 160
-80 -80 150
90 80 150
80 80 245
4
85 -90 290
-80 -80 220
-85 90 145
85 90 170
5
0 0 4
3 0 5
-3 0 5
0 3 5
0 -3 5
10
95 -93 260
-86 96 211
91 90 177
-81 -80 124
-91 91 144
97 94 165
-90 -86 194
89 85 167
-93 -80 222
92 -84 218
0
Output for the Sample Input
17.3205081
16.0000000
17.3205081
13.8011200
53.0000000
14.1421356
12.0000000
128.3928757
94.1879092
131.1240816
4.0000000
72.2251798
Example
Input
3
10 10 20
10 -10 20
-10 10 120
1
10 10 16
2
10 10 20
10 -10 20
2
100 0 101
-90 0 91
2
0 0 53
30 40 102
3
10 10 20
10 -10 20
-10 -10 20
3
1 5 13
5 -3 13
-3 -3 13
3
98 97 168
-82 -80 193
-99 -96 211
4
90 -100 160
-80 -80 150
90 80 150
80 80 245
4
85 -90 290
-80 -80 220
-85 90 145
85 90 170
5
0 0 4
3 0 5
-3 0 5
0 3 5
0 -3 5
10
95 -93 260
-86 96 211
91 90 177
-81 -80 124
-91 91 144
97 94 165
-90 -86 194
89 85 167
-93 -80 222
92 -84 218
0
Output
17.3205081
16.0000000
17.3205081
13.8011200
53.0000000
14.1421356
12.0000000
128.3928757
94.1879092
131.1240816
4.0000000
72.2251798 | instruction | 0 | 70,692 | 3 | 141,384 |
"Correct Solution:
```
"""http://mayokoex.hatenablog.com/entry/2015/06/11/124120を参照しました"""
"""三分探索、賢い"""
import sys
MI = 1e-6
def calc(x,y,b):
res = 90000
for bx,by,l in b:
d = l**2-(x-bx)**2-(y-by)**2
if d < res:
res = d
return res
def search_y(x,b):
p = [-100,-33,33,100]
for t in range(100):
if abs(p[0]-p[3]) < MI:
return (calc(x,p[0],b)+calc(x,p[3],b))/2
l = calc(x,p[1],b)
r = calc(x,p[2],b)
if l < r:
p[0] = p[1]
else:
p[3] = p[2]
p[1] = (2*p[0]+p[3])/3
p[2] = (p[0]+2*p[3])/3
return (calc(x,p[0],b)+calc(x,p[3],b))/2
def search(b):
p = [-100,-33,33,100]
for t in range(100):
if abs(p[0]-p[3]) < MI:
return (search_y(p[0],b)+search_y(p[3],b))/2
l = search_y(p[1],b)
r = search_y(p[2],b)
if l < r:
p[0] = p[1]
else:
p[3] = p[2]
p[1] = (2*p[0]+p[3])/3
p[2] = (p[0]+2*p[3])/3
return (search_y(p[0],b)+search_y(p[3],b))/2
def solve(n):
b = [[int(x) for x in sys.stdin.readline().split()] for i in range(n)]
ans = 0
print(search(b)**0.5)
while 1:
n = int(sys.stdin.readline())
if n == 0:
break
solve(n)
``` | output | 1 | 70,692 | 3 | 141,385 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
n robots have escaped from your laboratory! You have to find them as soon as possible, because these robots are experimental, and their behavior is not tested yet, so they may be really dangerous!
Fortunately, even though your robots have escaped, you still have some control over them. First of all, you know the location of each robot: the world you live in can be modeled as an infinite coordinate plane, and the i-th robot is currently located at the point having coordinates (x_i, y_i). Furthermore, you may send exactly one command to all of the robots. The command should contain two integer numbers X and Y, and when each robot receives this command, it starts moving towards the point having coordinates (X, Y). The robot stops its movement in two cases:
* either it reaches (X, Y);
* or it cannot get any closer to (X, Y).
Normally, all robots should be able to get from any point of the coordinate plane to any other point. Each robot usually can perform four actions to move. Let's denote the current coordinates of the robot as (x_c, y_c). Then the movement system allows it to move to any of the four adjacent points:
1. the first action allows it to move from (x_c, y_c) to (x_c - 1, y_c);
2. the second action allows it to move from (x_c, y_c) to (x_c, y_c + 1);
3. the third action allows it to move from (x_c, y_c) to (x_c + 1, y_c);
4. the fourth action allows it to move from (x_c, y_c) to (x_c, y_c - 1).
Unfortunately, it seems that some movement systems of some robots are malfunctioning. For each robot you know which actions it can perform, and which it cannot perform.
You want to send a command so all robots gather at the same point. To do so, you have to choose a pair of integer numbers X and Y so that each robot can reach the point (X, Y). Is it possible to find such a point?
Input
The first line contains one integer q (1 ≤ q ≤ 10^5) — the number of queries.
Then q queries follow. Each query begins with one line containing one integer n (1 ≤ n ≤ 10^5) — the number of robots in the query. Then n lines follow, the i-th of these lines describes the i-th robot in the current query: it contains six integer numbers x_i, y_i, f_{i, 1}, f_{i, 2}, f_{i, 3} and f_{i, 4} (-10^5 ≤ x_i, y_i ≤ 10^5, 0 ≤ f_{i, j} ≤ 1). The first two numbers describe the initial location of the i-th robot, and the following four numbers describe which actions the i-th robot can use to move (f_{i, j} = 1 if the i-th robot can use the j-th action, and f_{i, j} = 0 if it cannot use the j-th action).
It is guaranteed that the total number of robots over all queries does not exceed 10^5.
Output
You should answer each query independently, in the order these queries appear in the input.
To answer a query, you should do one of the following:
* if it is impossible to find a point that is reachable by all n robots, print one number 0 on a separate line;
* if it is possible to find a point that is reachable by all n robots, print three space-separated integers on the same line: 1 X Y, where X and Y are the coordinates of the point reachable by all n robots. Both X and Y should not exceed 10^5 by absolute value; it is guaranteed that if there exists at least one point reachable by all robots, then at least one of such points has both coordinates not exceeding 10^5 by absolute value.
Example
Input
4
2
-1 -2 0 0 0 0
-1 -2 0 0 0 0
3
1 5 1 1 1 1
2 5 0 1 0 1
3 5 1 0 0 0
2
1337 1337 0 1 1 1
1336 1337 1 1 0 1
1
3 5 1 1 1 1
Output
1 -1 -2
1 2 5
0
1 -100000 -100000
Submitted Solution:
```
from sys import stdin
input=stdin.readline
for _ in range(int(input())):
n=int(input())
c=[]
f=[]
for i in range(n):
l=list(map(int,input().split()))
c.append(l[:2])
f.append(l[2:])
l=-10**5
u=10**5
r=10**5
d=-10**5
for i in range(n):
if f[i][0]==0:
l=max(l,c[i][0])
if f[i][1]==0:
u=min(u,c[i][1])
if f[i][2]==0:
r=min(r,c[i][0])
if f[i][3]==0:
d=max(d,c[i][1])
if l<=r and u>=d:
print(1,l,u)
else:
print(0)
``` | instruction | 0 | 70,825 | 3 | 141,650 |
Yes | output | 1 | 70,825 | 3 | 141,651 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
n robots have escaped from your laboratory! You have to find them as soon as possible, because these robots are experimental, and their behavior is not tested yet, so they may be really dangerous!
Fortunately, even though your robots have escaped, you still have some control over them. First of all, you know the location of each robot: the world you live in can be modeled as an infinite coordinate plane, and the i-th robot is currently located at the point having coordinates (x_i, y_i). Furthermore, you may send exactly one command to all of the robots. The command should contain two integer numbers X and Y, and when each robot receives this command, it starts moving towards the point having coordinates (X, Y). The robot stops its movement in two cases:
* either it reaches (X, Y);
* or it cannot get any closer to (X, Y).
Normally, all robots should be able to get from any point of the coordinate plane to any other point. Each robot usually can perform four actions to move. Let's denote the current coordinates of the robot as (x_c, y_c). Then the movement system allows it to move to any of the four adjacent points:
1. the first action allows it to move from (x_c, y_c) to (x_c - 1, y_c);
2. the second action allows it to move from (x_c, y_c) to (x_c, y_c + 1);
3. the third action allows it to move from (x_c, y_c) to (x_c + 1, y_c);
4. the fourth action allows it to move from (x_c, y_c) to (x_c, y_c - 1).
Unfortunately, it seems that some movement systems of some robots are malfunctioning. For each robot you know which actions it can perform, and which it cannot perform.
You want to send a command so all robots gather at the same point. To do so, you have to choose a pair of integer numbers X and Y so that each robot can reach the point (X, Y). Is it possible to find such a point?
Input
The first line contains one integer q (1 ≤ q ≤ 10^5) — the number of queries.
Then q queries follow. Each query begins with one line containing one integer n (1 ≤ n ≤ 10^5) — the number of robots in the query. Then n lines follow, the i-th of these lines describes the i-th robot in the current query: it contains six integer numbers x_i, y_i, f_{i, 1}, f_{i, 2}, f_{i, 3} and f_{i, 4} (-10^5 ≤ x_i, y_i ≤ 10^5, 0 ≤ f_{i, j} ≤ 1). The first two numbers describe the initial location of the i-th robot, and the following four numbers describe which actions the i-th robot can use to move (f_{i, j} = 1 if the i-th robot can use the j-th action, and f_{i, j} = 0 if it cannot use the j-th action).
It is guaranteed that the total number of robots over all queries does not exceed 10^5.
Output
You should answer each query independently, in the order these queries appear in the input.
To answer a query, you should do one of the following:
* if it is impossible to find a point that is reachable by all n robots, print one number 0 on a separate line;
* if it is possible to find a point that is reachable by all n robots, print three space-separated integers on the same line: 1 X Y, where X and Y are the coordinates of the point reachable by all n robots. Both X and Y should not exceed 10^5 by absolute value; it is guaranteed that if there exists at least one point reachable by all robots, then at least one of such points has both coordinates not exceeding 10^5 by absolute value.
Example
Input
4
2
-1 -2 0 0 0 0
-1 -2 0 0 0 0
3
1 5 1 1 1 1
2 5 0 1 0 1
3 5 1 0 0 0
2
1337 1337 0 1 1 1
1336 1337 1 1 0 1
1
3 5 1 1 1 1
Output
1 -1 -2
1 2 5
0
1 -100000 -100000
Submitted Solution:
```
import sys
q = int(input())
for _ in range(q):
n = int(input())
minx, maxx, miny, maxy = -100000, 100000, -100000, 100000
for i in range(n):
x, y, f1, f2, f3, f4 = map(int, sys.stdin.readline().split())
if f1 == 0:
minx = max(x, minx)
if f3 == 0:
maxx = min(maxx, x)
if f2 == 0:
maxy = min(maxy, y)
if f4 == 0:
miny = max(y, miny)
if minx > maxx or miny > maxy:
print(0)
continue
else:
print(1, minx, miny)
``` | instruction | 0 | 70,826 | 3 | 141,652 |
Yes | output | 1 | 70,826 | 3 | 141,653 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
n robots have escaped from your laboratory! You have to find them as soon as possible, because these robots are experimental, and their behavior is not tested yet, so they may be really dangerous!
Fortunately, even though your robots have escaped, you still have some control over them. First of all, you know the location of each robot: the world you live in can be modeled as an infinite coordinate plane, and the i-th robot is currently located at the point having coordinates (x_i, y_i). Furthermore, you may send exactly one command to all of the robots. The command should contain two integer numbers X and Y, and when each robot receives this command, it starts moving towards the point having coordinates (X, Y). The robot stops its movement in two cases:
* either it reaches (X, Y);
* or it cannot get any closer to (X, Y).
Normally, all robots should be able to get from any point of the coordinate plane to any other point. Each robot usually can perform four actions to move. Let's denote the current coordinates of the robot as (x_c, y_c). Then the movement system allows it to move to any of the four adjacent points:
1. the first action allows it to move from (x_c, y_c) to (x_c - 1, y_c);
2. the second action allows it to move from (x_c, y_c) to (x_c, y_c + 1);
3. the third action allows it to move from (x_c, y_c) to (x_c + 1, y_c);
4. the fourth action allows it to move from (x_c, y_c) to (x_c, y_c - 1).
Unfortunately, it seems that some movement systems of some robots are malfunctioning. For each robot you know which actions it can perform, and which it cannot perform.
You want to send a command so all robots gather at the same point. To do so, you have to choose a pair of integer numbers X and Y so that each robot can reach the point (X, Y). Is it possible to find such a point?
Input
The first line contains one integer q (1 ≤ q ≤ 10^5) — the number of queries.
Then q queries follow. Each query begins with one line containing one integer n (1 ≤ n ≤ 10^5) — the number of robots in the query. Then n lines follow, the i-th of these lines describes the i-th robot in the current query: it contains six integer numbers x_i, y_i, f_{i, 1}, f_{i, 2}, f_{i, 3} and f_{i, 4} (-10^5 ≤ x_i, y_i ≤ 10^5, 0 ≤ f_{i, j} ≤ 1). The first two numbers describe the initial location of the i-th robot, and the following four numbers describe which actions the i-th robot can use to move (f_{i, j} = 1 if the i-th robot can use the j-th action, and f_{i, j} = 0 if it cannot use the j-th action).
It is guaranteed that the total number of robots over all queries does not exceed 10^5.
Output
You should answer each query independently, in the order these queries appear in the input.
To answer a query, you should do one of the following:
* if it is impossible to find a point that is reachable by all n robots, print one number 0 on a separate line;
* if it is possible to find a point that is reachable by all n robots, print three space-separated integers on the same line: 1 X Y, where X and Y are the coordinates of the point reachable by all n robots. Both X and Y should not exceed 10^5 by absolute value; it is guaranteed that if there exists at least one point reachable by all robots, then at least one of such points has both coordinates not exceeding 10^5 by absolute value.
Example
Input
4
2
-1 -2 0 0 0 0
-1 -2 0 0 0 0
3
1 5 1 1 1 1
2 5 0 1 0 1
3 5 1 0 0 0
2
1337 1337 0 1 1 1
1336 1337 1 1 0 1
1
3 5 1 1 1 1
Output
1 -1 -2
1 2 5
0
1 -100000 -100000
Submitted Solution:
```
from sys import stdin
M = 10 ** 5
def solve(points):
min_x, min_y, max_x, max_y = -M, -M, M, M
for p in points:
x, y, f1, f2, f3, f4 = p
if not f1:
min_x = max(x, min_x)
if not f3:
max_x = min(x, max_x)
if not f4:
min_y = max(min_y, y)
if not f2:
max_y = min(max_y, y)
if (min_x <= max_x) and (min_y <= max_y):
print(1, min_x, min_y)
else:
print(0)
q = int(stdin.readline().strip())
for _ in range(q):
n = int(stdin.readline().strip())
points = []
for _ in range(n):
points.append([int(i) for i in stdin.readline().strip().split()])
solve(points)
``` | instruction | 0 | 70,827 | 3 | 141,654 |
Yes | output | 1 | 70,827 | 3 | 141,655 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
n robots have escaped from your laboratory! You have to find them as soon as possible, because these robots are experimental, and their behavior is not tested yet, so they may be really dangerous!
Fortunately, even though your robots have escaped, you still have some control over them. First of all, you know the location of each robot: the world you live in can be modeled as an infinite coordinate plane, and the i-th robot is currently located at the point having coordinates (x_i, y_i). Furthermore, you may send exactly one command to all of the robots. The command should contain two integer numbers X and Y, and when each robot receives this command, it starts moving towards the point having coordinates (X, Y). The robot stops its movement in two cases:
* either it reaches (X, Y);
* or it cannot get any closer to (X, Y).
Normally, all robots should be able to get from any point of the coordinate plane to any other point. Each robot usually can perform four actions to move. Let's denote the current coordinates of the robot as (x_c, y_c). Then the movement system allows it to move to any of the four adjacent points:
1. the first action allows it to move from (x_c, y_c) to (x_c - 1, y_c);
2. the second action allows it to move from (x_c, y_c) to (x_c, y_c + 1);
3. the third action allows it to move from (x_c, y_c) to (x_c + 1, y_c);
4. the fourth action allows it to move from (x_c, y_c) to (x_c, y_c - 1).
Unfortunately, it seems that some movement systems of some robots are malfunctioning. For each robot you know which actions it can perform, and which it cannot perform.
You want to send a command so all robots gather at the same point. To do so, you have to choose a pair of integer numbers X and Y so that each robot can reach the point (X, Y). Is it possible to find such a point?
Input
The first line contains one integer q (1 ≤ q ≤ 10^5) — the number of queries.
Then q queries follow. Each query begins with one line containing one integer n (1 ≤ n ≤ 10^5) — the number of robots in the query. Then n lines follow, the i-th of these lines describes the i-th robot in the current query: it contains six integer numbers x_i, y_i, f_{i, 1}, f_{i, 2}, f_{i, 3} and f_{i, 4} (-10^5 ≤ x_i, y_i ≤ 10^5, 0 ≤ f_{i, j} ≤ 1). The first two numbers describe the initial location of the i-th robot, and the following four numbers describe which actions the i-th robot can use to move (f_{i, j} = 1 if the i-th robot can use the j-th action, and f_{i, j} = 0 if it cannot use the j-th action).
It is guaranteed that the total number of robots over all queries does not exceed 10^5.
Output
You should answer each query independently, in the order these queries appear in the input.
To answer a query, you should do one of the following:
* if it is impossible to find a point that is reachable by all n robots, print one number 0 on a separate line;
* if it is possible to find a point that is reachable by all n robots, print three space-separated integers on the same line: 1 X Y, where X and Y are the coordinates of the point reachable by all n robots. Both X and Y should not exceed 10^5 by absolute value; it is guaranteed that if there exists at least one point reachable by all robots, then at least one of such points has both coordinates not exceeding 10^5 by absolute value.
Example
Input
4
2
-1 -2 0 0 0 0
-1 -2 0 0 0 0
3
1 5 1 1 1 1
2 5 0 1 0 1
3 5 1 0 0 0
2
1337 1337 0 1 1 1
1336 1337 1 1 0 1
1
3 5 1 1 1 1
Output
1 -1 -2
1 2 5
0
1 -100000 -100000
Submitted Solution:
```
###### ### ####### ####### ## # ##### ### #####
# # # # # # # # # # # # # ###
# # # # # # # # # # # # # ###
###### ######### # # # # # # ######### #
###### ######### # # # # # # ######### #
# # # # # # # # # # #### # # #
# # # # # # # ## # # # # #
###### # # ####### ####### # # ##### # # # #
from __future__ import print_function # for PyPy2
from collections import Counter, OrderedDict
from itertools import permutations as perm
from fractions import Fraction
from collections import deque
from sys import stdin
from bisect import *
from heapq import *
# from math import *
g = lambda : stdin.readline().strip()
gl = lambda : g().split()
gil = lambda : [int(var) for var in gl()]
gfl = lambda : [float(var) for var in gl()]
gcl = lambda : list(g())
gbs = lambda : [int(var) for var in g()]
mod = int(1e9)+7
inf = float("inf")
# range = xrange
t, = gil()
for _ in range(t):
xmin, xmax = -int(1e5), int(1e5)
ymin, ymax = xmin, xmax
n, = gil()
isPos = True
for _ in range(n):
rx, ry, lt, up, rt, dw = gil()
if not isPos : continue
if lt^rt: #either left or right
if lt:
isPos &= (xmin <= rx)
xmax = min(xmax, rx)
else:
isPos &= (rx <= xmax)
xmin = max(xmin, rx)
elif lt == rt == 0:
isPos &= (xmin <= rx <= xmax)
xmax = xmin = rx
if up^dw : # either up or down
if up:
isPos &= (ry <= ymax)
ymin = max(ymin, ry)
else:
isPos &= (ry >= ymin)
ymax = min(ymax, ry)
elif up == dw == 0:
isPos &= (ymin <= ry <= ymax)
ymax = ymin = ry
if isPos:
print(1, xmin, ymin)
else:
print(0)
``` | instruction | 0 | 70,828 | 3 | 141,656 |
Yes | output | 1 | 70,828 | 3 | 141,657 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
n robots have escaped from your laboratory! You have to find them as soon as possible, because these robots are experimental, and their behavior is not tested yet, so they may be really dangerous!
Fortunately, even though your robots have escaped, you still have some control over them. First of all, you know the location of each robot: the world you live in can be modeled as an infinite coordinate plane, and the i-th robot is currently located at the point having coordinates (x_i, y_i). Furthermore, you may send exactly one command to all of the robots. The command should contain two integer numbers X and Y, and when each robot receives this command, it starts moving towards the point having coordinates (X, Y). The robot stops its movement in two cases:
* either it reaches (X, Y);
* or it cannot get any closer to (X, Y).
Normally, all robots should be able to get from any point of the coordinate plane to any other point. Each robot usually can perform four actions to move. Let's denote the current coordinates of the robot as (x_c, y_c). Then the movement system allows it to move to any of the four adjacent points:
1. the first action allows it to move from (x_c, y_c) to (x_c - 1, y_c);
2. the second action allows it to move from (x_c, y_c) to (x_c, y_c + 1);
3. the third action allows it to move from (x_c, y_c) to (x_c + 1, y_c);
4. the fourth action allows it to move from (x_c, y_c) to (x_c, y_c - 1).
Unfortunately, it seems that some movement systems of some robots are malfunctioning. For each robot you know which actions it can perform, and which it cannot perform.
You want to send a command so all robots gather at the same point. To do so, you have to choose a pair of integer numbers X and Y so that each robot can reach the point (X, Y). Is it possible to find such a point?
Input
The first line contains one integer q (1 ≤ q ≤ 10^5) — the number of queries.
Then q queries follow. Each query begins with one line containing one integer n (1 ≤ n ≤ 10^5) — the number of robots in the query. Then n lines follow, the i-th of these lines describes the i-th robot in the current query: it contains six integer numbers x_i, y_i, f_{i, 1}, f_{i, 2}, f_{i, 3} and f_{i, 4} (-10^5 ≤ x_i, y_i ≤ 10^5, 0 ≤ f_{i, j} ≤ 1). The first two numbers describe the initial location of the i-th robot, and the following four numbers describe which actions the i-th robot can use to move (f_{i, j} = 1 if the i-th robot can use the j-th action, and f_{i, j} = 0 if it cannot use the j-th action).
It is guaranteed that the total number of robots over all queries does not exceed 10^5.
Output
You should answer each query independently, in the order these queries appear in the input.
To answer a query, you should do one of the following:
* if it is impossible to find a point that is reachable by all n robots, print one number 0 on a separate line;
* if it is possible to find a point that is reachable by all n robots, print three space-separated integers on the same line: 1 X Y, where X and Y are the coordinates of the point reachable by all n robots. Both X and Y should not exceed 10^5 by absolute value; it is guaranteed that if there exists at least one point reachable by all robots, then at least one of such points has both coordinates not exceeding 10^5 by absolute value.
Example
Input
4
2
-1 -2 0 0 0 0
-1 -2 0 0 0 0
3
1 5 1 1 1 1
2 5 0 1 0 1
3 5 1 0 0 0
2
1337 1337 0 1 1 1
1336 1337 1 1 0 1
1
3 5 1 1 1 1
Output
1 -1 -2
1 2 5
0
1 -100000 -100000
Submitted Solution:
```
t=int(input())
while t>0:
t-=1
n=int(input())
b=[]
for i in range(n):
a=[int(x) for x in input().split()]
b.append(a)
#XYLDRU
L=[]
R=[]
U=[]
D=[]
for a in b:
if a[2]==0:
L.append(a[0])
if a[3]==0:
D.append(a[1])
if a[4]==0:
R.append(a[0])
if a[5]==0:
U.append(a[1])
L.sort(reverse=True)
R.sort()
U.sort(reverse=True)
D.sort()
if len(L)==0:
L.insert(0,-10000)
if len(U) ==0:
U.insert(0,-10000)
if len(R)==0:
R.insert(0,10000)
if len(D) ==0:
D.insert(0,10000)
if L[0]>R[0] or U[0]>D[0]:
print(0)
continue
print(1,L[0],U[0])
``` | instruction | 0 | 70,829 | 3 | 141,658 |
No | output | 1 | 70,829 | 3 | 141,659 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
n robots have escaped from your laboratory! You have to find them as soon as possible, because these robots are experimental, and their behavior is not tested yet, so they may be really dangerous!
Fortunately, even though your robots have escaped, you still have some control over them. First of all, you know the location of each robot: the world you live in can be modeled as an infinite coordinate plane, and the i-th robot is currently located at the point having coordinates (x_i, y_i). Furthermore, you may send exactly one command to all of the robots. The command should contain two integer numbers X and Y, and when each robot receives this command, it starts moving towards the point having coordinates (X, Y). The robot stops its movement in two cases:
* either it reaches (X, Y);
* or it cannot get any closer to (X, Y).
Normally, all robots should be able to get from any point of the coordinate plane to any other point. Each robot usually can perform four actions to move. Let's denote the current coordinates of the robot as (x_c, y_c). Then the movement system allows it to move to any of the four adjacent points:
1. the first action allows it to move from (x_c, y_c) to (x_c - 1, y_c);
2. the second action allows it to move from (x_c, y_c) to (x_c, y_c + 1);
3. the third action allows it to move from (x_c, y_c) to (x_c + 1, y_c);
4. the fourth action allows it to move from (x_c, y_c) to (x_c, y_c - 1).
Unfortunately, it seems that some movement systems of some robots are malfunctioning. For each robot you know which actions it can perform, and which it cannot perform.
You want to send a command so all robots gather at the same point. To do so, you have to choose a pair of integer numbers X and Y so that each robot can reach the point (X, Y). Is it possible to find such a point?
Input
The first line contains one integer q (1 ≤ q ≤ 10^5) — the number of queries.
Then q queries follow. Each query begins with one line containing one integer n (1 ≤ n ≤ 10^5) — the number of robots in the query. Then n lines follow, the i-th of these lines describes the i-th robot in the current query: it contains six integer numbers x_i, y_i, f_{i, 1}, f_{i, 2}, f_{i, 3} and f_{i, 4} (-10^5 ≤ x_i, y_i ≤ 10^5, 0 ≤ f_{i, j} ≤ 1). The first two numbers describe the initial location of the i-th robot, and the following four numbers describe which actions the i-th robot can use to move (f_{i, j} = 1 if the i-th robot can use the j-th action, and f_{i, j} = 0 if it cannot use the j-th action).
It is guaranteed that the total number of robots over all queries does not exceed 10^5.
Output
You should answer each query independently, in the order these queries appear in the input.
To answer a query, you should do one of the following:
* if it is impossible to find a point that is reachable by all n robots, print one number 0 on a separate line;
* if it is possible to find a point that is reachable by all n robots, print three space-separated integers on the same line: 1 X Y, where X and Y are the coordinates of the point reachable by all n robots. Both X and Y should not exceed 10^5 by absolute value; it is guaranteed that if there exists at least one point reachable by all robots, then at least one of such points has both coordinates not exceeding 10^5 by absolute value.
Example
Input
4
2
-1 -2 0 0 0 0
-1 -2 0 0 0 0
3
1 5 1 1 1 1
2 5 0 1 0 1
3 5 1 0 0 0
2
1337 1337 0 1 1 1
1336 1337 1 1 0 1
1
3 5 1 1 1 1
Output
1 -1 -2
1 2 5
0
1 -100000 -100000
Submitted Solution:
```
def intersection(X,curr,x):
if curr == 'a':
if X[0] > x:
return []
X[1] = min(X[1],x)
else:
if X[1] > x:
return []
X[0] = min(X[0],x)
return X
def solve(n,ans):
found = True
X = [-10**5,10**5]
Y = [-10**5,10**5]
for i in range(n):
x,y,a,b,c,d = map(int,input().split())
if found:
if a+c == 1:
if a == 1:
if not intersection(X,'a',x):
found = False
else:
if not intersection(X,'c',x):
found = False
elif a+c == 0:
if X[0] <= x and X[1] >= x:
X = [x,x]
else:
found = False
if b+d == 1:
if d == 1:
if not intersection(Y,'a',y):
found = False
else:
if not intersection(Y,'c',y):
found = False
elif b+d == 0:
if Y[0] <= y and Y[1] >= y:
Y = [y,y]
else:
found = False
#print(X,Y)
if not found:
ans.append(0)
else:
ans.append('1 '+str(X[0])+' '+str(Y[0]))
def main():
ans = []
q = int(input())
for i in range(q):
n = int(input())
solve(n,ans)
for i in ans:
print(i)
main()
``` | instruction | 0 | 70,830 | 3 | 141,660 |
No | output | 1 | 70,830 | 3 | 141,661 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
n robots have escaped from your laboratory! You have to find them as soon as possible, because these robots are experimental, and their behavior is not tested yet, so they may be really dangerous!
Fortunately, even though your robots have escaped, you still have some control over them. First of all, you know the location of each robot: the world you live in can be modeled as an infinite coordinate plane, and the i-th robot is currently located at the point having coordinates (x_i, y_i). Furthermore, you may send exactly one command to all of the robots. The command should contain two integer numbers X and Y, and when each robot receives this command, it starts moving towards the point having coordinates (X, Y). The robot stops its movement in two cases:
* either it reaches (X, Y);
* or it cannot get any closer to (X, Y).
Normally, all robots should be able to get from any point of the coordinate plane to any other point. Each robot usually can perform four actions to move. Let's denote the current coordinates of the robot as (x_c, y_c). Then the movement system allows it to move to any of the four adjacent points:
1. the first action allows it to move from (x_c, y_c) to (x_c - 1, y_c);
2. the second action allows it to move from (x_c, y_c) to (x_c, y_c + 1);
3. the third action allows it to move from (x_c, y_c) to (x_c + 1, y_c);
4. the fourth action allows it to move from (x_c, y_c) to (x_c, y_c - 1).
Unfortunately, it seems that some movement systems of some robots are malfunctioning. For each robot you know which actions it can perform, and which it cannot perform.
You want to send a command so all robots gather at the same point. To do so, you have to choose a pair of integer numbers X and Y so that each robot can reach the point (X, Y). Is it possible to find such a point?
Input
The first line contains one integer q (1 ≤ q ≤ 10^5) — the number of queries.
Then q queries follow. Each query begins with one line containing one integer n (1 ≤ n ≤ 10^5) — the number of robots in the query. Then n lines follow, the i-th of these lines describes the i-th robot in the current query: it contains six integer numbers x_i, y_i, f_{i, 1}, f_{i, 2}, f_{i, 3} and f_{i, 4} (-10^5 ≤ x_i, y_i ≤ 10^5, 0 ≤ f_{i, j} ≤ 1). The first two numbers describe the initial location of the i-th robot, and the following four numbers describe which actions the i-th robot can use to move (f_{i, j} = 1 if the i-th robot can use the j-th action, and f_{i, j} = 0 if it cannot use the j-th action).
It is guaranteed that the total number of robots over all queries does not exceed 10^5.
Output
You should answer each query independently, in the order these queries appear in the input.
To answer a query, you should do one of the following:
* if it is impossible to find a point that is reachable by all n robots, print one number 0 on a separate line;
* if it is possible to find a point that is reachable by all n robots, print three space-separated integers on the same line: 1 X Y, where X and Y are the coordinates of the point reachable by all n robots. Both X and Y should not exceed 10^5 by absolute value; it is guaranteed that if there exists at least one point reachable by all robots, then at least one of such points has both coordinates not exceeding 10^5 by absolute value.
Example
Input
4
2
-1 -2 0 0 0 0
-1 -2 0 0 0 0
3
1 5 1 1 1 1
2 5 0 1 0 1
3 5 1 0 0 0
2
1337 1337 0 1 1 1
1336 1337 1 1 0 1
1
3 5 1 1 1 1
Output
1 -1 -2
1 2 5
0
1 -100000 -100000
Submitted Solution:
```
import sys
#sys.stdin = open("input.txt")
t = int(input())
for i in range (t):
n = int(input())
p = []
X = 0
Y = 0
for k in range (n):
x,y,s,a,d,b = map(int,input().split())
p.append([x,y,s,a,d,b])
if (n == 1):
if (p[0][5] == 1 and p[0][2] == 1 ):
X = -100000
Y = -100000
else:
X = p[0][0]
Y = p[0][1]
print(1,X,Y)
else:
verdetto = True
for k in range (n-1):
for z in range (k+1,n):
if ( p[k][0] > p[z][0]):
if (p[z][4] == 0 and p[k][2] == 0):
verdetto = False
if (p[k][0] < p[z][0]):
if (p[k][4] == 0 and p[z][2] == 0):
verdetto = False
if (p[k][1] > p[z][1]):
if (p[z][3] == 0 and p[k][5] == 0):
verdetto = False
if (p[k][1] < p[z][1]):
if (p[k][3] == 0 and p[z][5] == 0):
verdetto = False
if verdetto == True:
for k in range (n-1):
if (p[k][0]!= p[k+1][0]):
if (p[k][0]>p[k+1][0]):
dx = p[k][0]-p[k+1][0]
if (p[k+1][4] == 1):
X = p[k][0]
else:
X = p[k+1][0]
else:
dx = p[k+1][0]-p[k][0]
if (p[k][4] == 1):
X = p[k+1][0]
else:
X = p[k][0]
else:
X = p[k][0]
if (p[k][1]!=p[k+1][1]):
if (p[k][1]>=p[k+1][1]):
dy = p[k][1]-p[k+1][1]
if (p[k+1][3] == 1):
Y = p[k][1]
else:
Y = p[k+1][1]
else:
dy = p[k+1][1]-p[k][1]
if (p[k][3] == 1):
Y = p[k+1][1]
else:
Y = p[k][1]
else:
Y = p[k][1]
print(1,X,Y)
else:
print(0)
``` | instruction | 0 | 70,831 | 3 | 141,662 |
No | output | 1 | 70,831 | 3 | 141,663 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
n robots have escaped from your laboratory! You have to find them as soon as possible, because these robots are experimental, and their behavior is not tested yet, so they may be really dangerous!
Fortunately, even though your robots have escaped, you still have some control over them. First of all, you know the location of each robot: the world you live in can be modeled as an infinite coordinate plane, and the i-th robot is currently located at the point having coordinates (x_i, y_i). Furthermore, you may send exactly one command to all of the robots. The command should contain two integer numbers X and Y, and when each robot receives this command, it starts moving towards the point having coordinates (X, Y). The robot stops its movement in two cases:
* either it reaches (X, Y);
* or it cannot get any closer to (X, Y).
Normally, all robots should be able to get from any point of the coordinate plane to any other point. Each robot usually can perform four actions to move. Let's denote the current coordinates of the robot as (x_c, y_c). Then the movement system allows it to move to any of the four adjacent points:
1. the first action allows it to move from (x_c, y_c) to (x_c - 1, y_c);
2. the second action allows it to move from (x_c, y_c) to (x_c, y_c + 1);
3. the third action allows it to move from (x_c, y_c) to (x_c + 1, y_c);
4. the fourth action allows it to move from (x_c, y_c) to (x_c, y_c - 1).
Unfortunately, it seems that some movement systems of some robots are malfunctioning. For each robot you know which actions it can perform, and which it cannot perform.
You want to send a command so all robots gather at the same point. To do so, you have to choose a pair of integer numbers X and Y so that each robot can reach the point (X, Y). Is it possible to find such a point?
Input
The first line contains one integer q (1 ≤ q ≤ 10^5) — the number of queries.
Then q queries follow. Each query begins with one line containing one integer n (1 ≤ n ≤ 10^5) — the number of robots in the query. Then n lines follow, the i-th of these lines describes the i-th robot in the current query: it contains six integer numbers x_i, y_i, f_{i, 1}, f_{i, 2}, f_{i, 3} and f_{i, 4} (-10^5 ≤ x_i, y_i ≤ 10^5, 0 ≤ f_{i, j} ≤ 1). The first two numbers describe the initial location of the i-th robot, and the following four numbers describe which actions the i-th robot can use to move (f_{i, j} = 1 if the i-th robot can use the j-th action, and f_{i, j} = 0 if it cannot use the j-th action).
It is guaranteed that the total number of robots over all queries does not exceed 10^5.
Output
You should answer each query independently, in the order these queries appear in the input.
To answer a query, you should do one of the following:
* if it is impossible to find a point that is reachable by all n robots, print one number 0 on a separate line;
* if it is possible to find a point that is reachable by all n robots, print three space-separated integers on the same line: 1 X Y, where X and Y are the coordinates of the point reachable by all n robots. Both X and Y should not exceed 10^5 by absolute value; it is guaranteed that if there exists at least one point reachable by all robots, then at least one of such points has both coordinates not exceeding 10^5 by absolute value.
Example
Input
4
2
-1 -2 0 0 0 0
-1 -2 0 0 0 0
3
1 5 1 1 1 1
2 5 0 1 0 1
3 5 1 0 0 0
2
1337 1337 0 1 1 1
1336 1337 1 1 0 1
1
3 5 1 1 1 1
Output
1 -1 -2
1 2 5
0
1 -100000 -100000
Submitted Solution:
```
#from sys import stdin,stdout
#input=stdin.readline
#import math,bisect
#from itertools import permutations
#from collections import Counter
for _ in range(int(input())):
n=int(input())
mxx=100000
mnx=-100000
mxy=100000
mny=-100000
sab=[]
for i in range(n):
x,y,left,up,right,down=map(int,input().split())
if left==right==up==down==0:
sab.append([x,y])
else:
if left==0:
if mnx<x:
mnx=max(mnx,x)
if right==0:
if mxx>x:
mxx=min(mxx,x)
if up==0:
if mxy>y:
mxy=min(mxy,y)
if down==0:
if mny<y:
mny=max(mny,y)
if mnx>mxx or mny>mxy:
print(0)
else:
if len(sab)==0:
print(1,mnx,mny)
elif len(sab)==1:
print(sab[0][0])
elif len(sab)>1:
f=0
x1=sab[0][0]
y1=sab[0][1]
for i in range(1,len(sab)):
if x1!=sab[i][0] or y1!=sab[i][1]:
f=1
if f==1:
print(0)
else:
print(1,x1,y1)
else:
print(1,mxx,mxy)
``` | instruction | 0 | 70,832 | 3 | 141,664 |
No | output | 1 | 70,832 | 3 | 141,665 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
Mr. Chanek is currently participating in a science fair that is popular in town. He finds an exciting puzzle in the fair and wants to solve it.
There are N atoms numbered from 1 to N. These atoms are especially quirky. Initially, each atom is in normal state. Each atom can be in an excited. Exciting atom i requires D_i energy. When atom i is excited, it will give A_i energy. You can excite any number of atoms (including zero).
These atoms also form a peculiar one-way bond. For each i, (1 ≤ i < N), if atom i is excited, atom E_i will also be excited at no cost. Initially, E_i = i+1. Note that atom N cannot form a bond to any atom.
Mr. Chanek must change exactly K bonds. Exactly K times, Mr. Chanek chooses an atom i, (1 ≤ i < N) and changes E_i to a different value other than i and the current E_i. Note that an atom's bond can remain unchanged or changed more than once. Help Mr. Chanek determine the maximum energy that he can achieve!
note: You must first change exactly K bonds before you can start exciting atoms.
Input
The first line contains two integers N K (4 ≤ N ≤ 10^5, 0 ≤ K < N), the number of atoms, and the number of bonds that must be changed.
The second line contains N integers A_i (1 ≤ A_i ≤ 10^6), which denotes the energy given by atom i when on excited state.
The third line contains N integers D_i (1 ≤ D_i ≤ 10^6), which denotes the energy needed to excite atom i.
Output
A line with an integer that denotes the maximum number of energy that Mr. Chanek can get.
Example
Input
6 1
5 6 7 8 10 2
3 5 6 7 1 10
Output
35
Note
An optimal solution to change E_5 to 1 and then excite atom 5 with energy 1. It will cause atoms 1, 2, 3, 4, 5 be excited. The total energy gained by Mr. Chanek is (5 + 6 + 7 + 8 + 10) - 1 = 35.
Another possible way is to change E_3 to 1 and then exciting atom 3 (which will excite atom 1, 2, 3) and exciting atom 4 (which will excite atom 4, 5, 6). The total energy gained by Mr. Chanek is (5 + 6 + 7 + 8 + 10 + 2) - (6 + 7) = 25 which is not optimal.
Submitted Solution:
```
import sys
n, k = list(map(int, input().split(' ')))
activate = list(map(int, input().split(' '))) # 释放的能量
deactivate = list(map(int, input().split(' '))) # 需求的能量
ls = list(zip(activate[0:-1], deactivate[0:-1]))
diff = ls[0][0] - ls[0][1]
presum = [0 for _ in range(n + 2)]
for i in range(1, n + 1):
presum[i] = presum[i - 1] + activate[i - 1]
ret = 0
if k == 0:
for i in range(1, n + 1):
# 情况0，不需要考虑连带
ret = max(ret, presum[n] - presum[i - 1] - deactivate[i - 1])
elif k == 1:
ret = max(ret, presum[n - 1] - min(deactivate), presum[n] - min(deactivate) - deactivate[n - 1])
deac = sorted(deactivate[0:n - 1])
ac = sorted(activate[1:n - 1])
# 情况5，激活1，跳过1个节点
ret = max(ret, presum[n] - deactivate[0] - ac[0])
# 情况4
ret = max(ret, presum[n] - deac[0] - deac[1])
# 情况7 1连n，激活i
for i in range(2, n + 1):
ret = max(ret, presum[n] - presum[i - 1] - deactivate[i - 1])
else:
# 情况1
for i in range(1, n):
ret = max(ret, presum[n] - deactivate[i - 1])
# 情况2
ret = max(ret, activate[n - 1] - deactivate[n - 1])
print(ret)
``` | instruction | 0 | 70,921 | 3 | 141,842 |
Yes | output | 1 | 70,921 | 3 | 141,843 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
Mr. Chanek is currently participating in a science fair that is popular in town. He finds an exciting puzzle in the fair and wants to solve it.
There are N atoms numbered from 1 to N. These atoms are especially quirky. Initially, each atom is in normal state. Each atom can be in an excited. Exciting atom i requires D_i energy. When atom i is excited, it will give A_i energy. You can excite any number of atoms (including zero).
These atoms also form a peculiar one-way bond. For each i, (1 ≤ i < N), if atom i is excited, atom E_i will also be excited at no cost. Initially, E_i = i+1. Note that atom N cannot form a bond to any atom.
Mr. Chanek must change exactly K bonds. Exactly K times, Mr. Chanek chooses an atom i, (1 ≤ i < N) and changes E_i to a different value other than i and the current E_i. Note that an atom's bond can remain unchanged or changed more than once. Help Mr. Chanek determine the maximum energy that he can achieve!
note: You must first change exactly K bonds before you can start exciting atoms.
Input
The first line contains two integers N K (4 ≤ N ≤ 10^5, 0 ≤ K < N), the number of atoms, and the number of bonds that must be changed.
The second line contains N integers A_i (1 ≤ A_i ≤ 10^6), which denotes the energy given by atom i when on excited state.
The third line contains N integers D_i (1 ≤ D_i ≤ 10^6), which denotes the energy needed to excite atom i.
Output
A line with an integer that denotes the maximum number of energy that Mr. Chanek can get.
Example
Input
6 1
5 6 7 8 10 2
3 5 6 7 1 10
Output
35
Note
An optimal solution to change E_5 to 1 and then excite atom 5 with energy 1. It will cause atoms 1, 2, 3, 4, 5 be excited. The total energy gained by Mr. Chanek is (5 + 6 + 7 + 8 + 10) - 1 = 35.
Another possible way is to change E_3 to 1 and then exciting atom 3 (which will excite atom 1, 2, 3) and exciting atom 4 (which will excite atom 4, 5, 6). The total energy gained by Mr. Chanek is (5 + 6 + 7 + 8 + 10 + 2) - (6 + 7) = 25 which is not optimal.
Submitted Solution:
```
N, K = map(int, input().split())
A = list(map(int, input().split()))
D = list(map(int, input().split()))
suf_min = [None]*N
suf_min[-1] = A[-1]
suf_sum = [None]*N
suf_sum[-1] = A[-1]
suf_ans = [None]*N
suf_ans[-1] = max(A[-1] - D[-1], 0)
for i in range(N-2, -1, -1):
suf_min[i] = min(A[i], suf_min[i+1])
suf_sum[i] = suf_sum[i+1] + A[i]
suf_ans[i] = max(suf_ans[i+1], suf_sum[i]-D[i])
# print(i, suf_ans[i])
if K >= 2:
print(max(0, sum(A) - min(*D[:-1]), suf_ans[0]))
exit(0)
if K == 0:
print(max(suf_ans[0], 0))
exit(0)
pre_min = D[0]
pre_sum = 0
ans = max(0, sum(A) - D[0] - suf_min[0])
for i in range(N-1):
pre_sum += A[i]
pre_min = min(pre_min, D[i])
ans = max(ans, pre_sum - pre_min + suf_ans[i+1], suf_ans[i+1])
print(max(0, ans))
``` | instruction | 0 | 70,922 | 3 | 141,844 |
Yes | output | 1 | 70,922 | 3 | 141,845 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
Mr. Chanek is currently participating in a science fair that is popular in town. He finds an exciting puzzle in the fair and wants to solve it.
There are N atoms numbered from 1 to N. These atoms are especially quirky. Initially, each atom is in normal state. Each atom can be in an excited. Exciting atom i requires D_i energy. When atom i is excited, it will give A_i energy. You can excite any number of atoms (including zero).
These atoms also form a peculiar one-way bond. For each i, (1 ≤ i < N), if atom i is excited, atom E_i will also be excited at no cost. Initially, E_i = i+1. Note that atom N cannot form a bond to any atom.
Mr. Chanek must change exactly K bonds. Exactly K times, Mr. Chanek chooses an atom i, (1 ≤ i < N) and changes E_i to a different value other than i and the current E_i. Note that an atom's bond can remain unchanged or changed more than once. Help Mr. Chanek determine the maximum energy that he can achieve!
note: You must first change exactly K bonds before you can start exciting atoms.
Input
The first line contains two integers N K (4 ≤ N ≤ 10^5, 0 ≤ K < N), the number of atoms, and the number of bonds that must be changed.
The second line contains N integers A_i (1 ≤ A_i ≤ 10^6), which denotes the energy given by atom i when on excited state.
The third line contains N integers D_i (1 ≤ D_i ≤ 10^6), which denotes the energy needed to excite atom i.
Output
A line with an integer that denotes the maximum number of energy that Mr. Chanek can get.
Example
Input
6 1
5 6 7 8 10 2
3 5 6 7 1 10
Output
35
Note
An optimal solution to change E_5 to 1 and then excite atom 5 with energy 1. It will cause atoms 1, 2, 3, 4, 5 be excited. The total energy gained by Mr. Chanek is (5 + 6 + 7 + 8 + 10) - 1 = 35.
Another possible way is to change E_3 to 1 and then exciting atom 3 (which will excite atom 1, 2, 3) and exciting atom 4 (which will excite atom 4, 5, 6). The total energy gained by Mr. Chanek is (5 + 6 + 7 + 8 + 10 + 2) - (6 + 7) = 25 which is not optimal.
Submitted Solution:
```
import os
import sys
from io import BytesIO, IOBase
# region fastio
BUFSIZE = 8192
class FastIO(IOBase):
newlines = 0
def __init__(self, file):
import os
self.os = os
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 = self.os.read(self._fd, max(self.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 = self.os.read(self._fd, max(self.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:
self.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")
# ------------------------------
n, k = map(int, input().split())
a = list(map(int, input().split()))
d = list(map(int, input().split()))
if k >= 2:
m = min(d[: -1])
print(max(sum(a) - m, a[-1] - d[-1], 0))
elif k == 0:
rightans = [0] * n
cursum = 0
ans = 0
for i in range(n - 1, -1, -1):
cursum += a[i]
rightans[i] = max(cursum - d[i], 0)
print(max(rightans))
else:
leftd = int(1e9)
leftsum = 0
rightans = [0] * n
cursum = 0
ans = 0
for i in range(n - 1, -1, -1):
cursum += a[i]
rightans[i] = max(cursum - d[i], 0)
for i in range(n - 1, 0, -1):
rightans[i - 1] = max(rightans[i - 1], rightans[i])
for i in range(n - 1):
leftd = min(leftd, d[i])
leftsum += a[i]
curans = max(leftsum - leftd, 0) + rightans[i + 1]
ans = max(ans, curans)
cursum = 0
rightmin = int(1e9)
for i in range(n - 1, -1, -1):
cursum += a[i]
ans = max(ans, cursum - rightmin - d[i])
rightmin = min(rightmin, a[i])
print(ans)
``` | instruction | 0 | 70,923 | 3 | 141,846 |
Yes | output | 1 | 70,923 | 3 | 141,847 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
Mr. Chanek is currently participating in a science fair that is popular in town. He finds an exciting puzzle in the fair and wants to solve it.
There are N atoms numbered from 1 to N. These atoms are especially quirky. Initially, each atom is in normal state. Each atom can be in an excited. Exciting atom i requires D_i energy. When atom i is excited, it will give A_i energy. You can excite any number of atoms (including zero).
These atoms also form a peculiar one-way bond. For each i, (1 ≤ i < N), if atom i is excited, atom E_i will also be excited at no cost. Initially, E_i = i+1. Note that atom N cannot form a bond to any atom.
Mr. Chanek must change exactly K bonds. Exactly K times, Mr. Chanek chooses an atom i, (1 ≤ i < N) and changes E_i to a different value other than i and the current E_i. Note that an atom's bond can remain unchanged or changed more than once. Help Mr. Chanek determine the maximum energy that he can achieve!
note: You must first change exactly K bonds before you can start exciting atoms.
Input
The first line contains two integers N K (4 ≤ N ≤ 10^5, 0 ≤ K < N), the number of atoms, and the number of bonds that must be changed.
The second line contains N integers A_i (1 ≤ A_i ≤ 10^6), which denotes the energy given by atom i when on excited state.
The third line contains N integers D_i (1 ≤ D_i ≤ 10^6), which denotes the energy needed to excite atom i.
Output
A line with an integer that denotes the maximum number of energy that Mr. Chanek can get.
Example
Input
6 1
5 6 7 8 10 2
3 5 6 7 1 10
Output
35
Note
An optimal solution to change E_5 to 1 and then excite atom 5 with energy 1. It will cause atoms 1, 2, 3, 4, 5 be excited. The total energy gained by Mr. Chanek is (5 + 6 + 7 + 8 + 10) - 1 = 35.
Another possible way is to change E_3 to 1 and then exciting atom 3 (which will excite atom 1, 2, 3) and exciting atom 4 (which will excite atom 4, 5, 6). The total energy gained by Mr. Chanek is (5 + 6 + 7 + 8 + 10 + 2) - (6 + 7) = 25 which is not optimal.
Submitted Solution:
```
import sys
n, k = list(map(int, input().split(' ')))
activate = list(map(int, input().split(' ')))
deactivate = list(map(int, input().split(' ')))
presum = [0 for _ in range(n+2)]
for i in range(1, n+1):
presum[i] = presum[i-1] + activate[i-1]
ret = 0
if k == 0:
for i in range(1, n+1):
ret = max(ret, presum[n] - presum[i-1] - deactivate[i-1])
elif k == 1:
for i in range(1, n):
ret = max(ret, presum[n-1] - deactivate[i-1])
if deactivate[n-1] < activate[n-1]:
ret += (activate[n-1] - deactivate[n-1])
deac = sorted(deactivate[1:n-1])
ac = sorted(activate[1:n-1])
ret = max(ret, presum[n] - deac[0] - deac[1])
ret = max(ret, presum[n] - deactivate[0] - ac[0])
ret = max(ret, presum[n] - deactivate[0] - deac[0])
for i in range(2, n+1):
ret = max(ret, presum[n] - presum[i-1] - deactivate[i-1])
else:
for i in range(1, n):
ret = max(ret, presum[n] - deactivate[i-1])
ret = max(ret, activate[n-1] - deactivate[n-1])
print(ret)
``` | instruction | 0 | 70,924 | 3 | 141,848 |
Yes | output | 1 | 70,924 | 3 | 141,849 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
Mr. Chanek is currently participating in a science fair that is popular in town. He finds an exciting puzzle in the fair and wants to solve it.
There are N atoms numbered from 1 to N. These atoms are especially quirky. Initially, each atom is in normal state. Each atom can be in an excited. Exciting atom i requires D_i energy. When atom i is excited, it will give A_i energy. You can excite any number of atoms (including zero).
These atoms also form a peculiar one-way bond. For each i, (1 ≤ i < N), if atom i is excited, atom E_i will also be excited at no cost. Initially, E_i = i+1. Note that atom N cannot form a bond to any atom.
Mr. Chanek must change exactly K bonds. Exactly K times, Mr. Chanek chooses an atom i, (1 ≤ i < N) and changes E_i to a different value other than i and the current E_i. Note that an atom's bond can remain unchanged or changed more than once. Help Mr. Chanek determine the maximum energy that he can achieve!
note: You must first change exactly K bonds before you can start exciting atoms.
Input
The first line contains two integers N K (4 ≤ N ≤ 10^5, 0 ≤ K < N), the number of atoms, and the number of bonds that must be changed.
The second line contains N integers A_i (1 ≤ A_i ≤ 10^6), which denotes the energy given by atom i when on excited state.
The third line contains N integers D_i (1 ≤ D_i ≤ 10^6), which denotes the energy needed to excite atom i.
Output
A line with an integer that denotes the maximum number of energy that Mr. Chanek can get.
Example
Input
6 1
5 6 7 8 10 2
3 5 6 7 1 10
Output
35
Note
An optimal solution to change E_5 to 1 and then excite atom 5 with energy 1. It will cause atoms 1, 2, 3, 4, 5 be excited. The total energy gained by Mr. Chanek is (5 + 6 + 7 + 8 + 10) - 1 = 35.
Another possible way is to change E_3 to 1 and then exciting atom 3 (which will excite atom 1, 2, 3) and exciting atom 4 (which will excite atom 4, 5, 6). The total energy gained by Mr. Chanek is (5 + 6 + 7 + 8 + 10 + 2) - (6 + 7) = 25 which is not optimal.
Submitted Solution:
```
n, k = map(int, input().split())
a = list(map(int, input().split()))
d = list(map(int, input().split()))
if k == 0:
best = 0
curr = sum(a)
for i in range(n):
best = max(best, curr - d[i])
curr -= a[i]
print(best)
elif k == 1:
best = sum(a[:-1]) - min(d[:-1])
other = sum(a)
other -= sorted(d)[0]
other -= sorted(d)[1]
curr = sum(a)
for i in range(n):
if i:
best = max(best, curr - d[i])
curr -= a[i]
o2 = sum(a) - a[1] - d[0]
print(max((best,other,0, o2)))
else:
print(max((sum(a) - min(d[:-1]),0,a[-1] - d[-1])))
``` | instruction | 0 | 70,925 | 3 | 141,850 |
No | output | 1 | 70,925 | 3 | 141,851 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
Mr. Chanek is currently participating in a science fair that is popular in town. He finds an exciting puzzle in the fair and wants to solve it.
There are N atoms numbered from 1 to N. These atoms are especially quirky. Initially, each atom is in normal state. Each atom can be in an excited. Exciting atom i requires D_i energy. When atom i is excited, it will give A_i energy. You can excite any number of atoms (including zero).
These atoms also form a peculiar one-way bond. For each i, (1 ≤ i < N), if atom i is excited, atom E_i will also be excited at no cost. Initially, E_i = i+1. Note that atom N cannot form a bond to any atom.
Mr. Chanek must change exactly K bonds. Exactly K times, Mr. Chanek chooses an atom i, (1 ≤ i < N) and changes E_i to a different value other than i and the current E_i. Note that an atom's bond can remain unchanged or changed more than once. Help Mr. Chanek determine the maximum energy that he can achieve!
note: You must first change exactly K bonds before you can start exciting atoms.
Input
The first line contains two integers N K (4 ≤ N ≤ 10^5, 0 ≤ K < N), the number of atoms, and the number of bonds that must be changed.
The second line contains N integers A_i (1 ≤ A_i ≤ 10^6), which denotes the energy given by atom i when on excited state.
The third line contains N integers D_i (1 ≤ D_i ≤ 10^6), which denotes the energy needed to excite atom i.
Output
A line with an integer that denotes the maximum number of energy that Mr. Chanek can get.
Example
Input
6 1
5 6 7 8 10 2
3 5 6 7 1 10
Output
35
Note
An optimal solution to change E_5 to 1 and then excite atom 5 with energy 1. It will cause atoms 1, 2, 3, 4, 5 be excited. The total energy gained by Mr. Chanek is (5 + 6 + 7 + 8 + 10) - 1 = 35.
Another possible way is to change E_3 to 1 and then exciting atom 3 (which will excite atom 1, 2, 3) and exciting atom 4 (which will excite atom 4, 5, 6). The total energy gained by Mr. Chanek is (5 + 6 + 7 + 8 + 10 + 2) - (6 + 7) = 25 which is not optimal.
Submitted Solution:
```
n, k = map(int, input().split())
a = list(map(int, input().split()))
d = list(map(int, input().split()))
if k >= 2:
m = min(a)
print(max(sum(a) - m, 0))
elif k == 0:
ans = False
for i, (ai, di) in enumerate(zip(a, d)):
if ai >= di:
ans = True
break
if ans:
print(sum(a[j] for j in range(i, n)) - d[i])
else:
print(0)
else:
ans = False
for i, (ai, di) in enumerate(zip(a, d)):
if ai >= di:
ans = True
break
if ans:
ans = sum(a[j] for j in range(i, n)) - d[i]
else:
ans = 0
m = min(a[: -1])
ans = max(ans, sum(a[: -1]) - m, 0)
print(ans)
``` | instruction | 0 | 70,926 | 3 | 141,852 |
No | output | 1 | 70,926 | 3 | 141,853 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
Mr. Chanek is currently participating in a science fair that is popular in town. He finds an exciting puzzle in the fair and wants to solve it.
There are N atoms numbered from 1 to N. These atoms are especially quirky. Initially, each atom is in normal state. Each atom can be in an excited. Exciting atom i requires D_i energy. When atom i is excited, it will give A_i energy. You can excite any number of atoms (including zero).
These atoms also form a peculiar one-way bond. For each i, (1 ≤ i < N), if atom i is excited, atom E_i will also be excited at no cost. Initially, E_i = i+1. Note that atom N cannot form a bond to any atom.
Mr. Chanek must change exactly K bonds. Exactly K times, Mr. Chanek chooses an atom i, (1 ≤ i < N) and changes E_i to a different value other than i and the current E_i. Note that an atom's bond can remain unchanged or changed more than once. Help Mr. Chanek determine the maximum energy that he can achieve!
note: You must first change exactly K bonds before you can start exciting atoms.
Input
The first line contains two integers N K (4 ≤ N ≤ 10^5, 0 ≤ K < N), the number of atoms, and the number of bonds that must be changed.
The second line contains N integers A_i (1 ≤ A_i ≤ 10^6), which denotes the energy given by atom i when on excited state.
The third line contains N integers D_i (1 ≤ D_i ≤ 10^6), which denotes the energy needed to excite atom i.
Output
A line with an integer that denotes the maximum number of energy that Mr. Chanek can get.
Example
Input
6 1
5 6 7 8 10 2
3 5 6 7 1 10
Output
35
Note
An optimal solution to change E_5 to 1 and then excite atom 5 with energy 1. It will cause atoms 1, 2, 3, 4, 5 be excited. The total energy gained by Mr. Chanek is (5 + 6 + 7 + 8 + 10) - 1 = 35.
Another possible way is to change E_3 to 1 and then exciting atom 3 (which will excite atom 1, 2, 3) and exciting atom 4 (which will excite atom 4, 5, 6). The total energy gained by Mr. Chanek is (5 + 6 + 7 + 8 + 10 + 2) - (6 + 7) = 25 which is not optimal.
Submitted Solution:
```
# by the authority of GOD author: manhar singh sachdev #
import os,sys
from io import BytesIO,IOBase
def main():
n,k = map(int,input().split())
a = list(map(int,input().split()))
d = list(map(int,input().split()))
mini = [a[-2]]
for i in range(n-3,0,-1):
mini.append(min(mini[-1],a[i]))
mini.reverse()
mini.extend([10**10,10**10])
ans,ans1,x,y = 0,0,sum(a),sum(a)
for i in range(n):
ans = max(ans,x-d[i])
ans1 = max(ans1,y-a[-1]-d[i],x-d[i]-mini[i])
x -= a[i]
if k >= 2:
print(max(0,sum(a)-min(d[:-1]),a[-1]-d[-1]))
elif k:
print(ans1)
else:
print(ans)
#Fast IO Region
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")
if __name__ == '__main__':
main()
``` | instruction | 0 | 70,927 | 3 | 141,854 |
No | output | 1 | 70,927 | 3 | 141,855 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
Mr. Chanek is currently participating in a science fair that is popular in town. He finds an exciting puzzle in the fair and wants to solve it.
There are N atoms numbered from 1 to N. These atoms are especially quirky. Initially, each atom is in normal state. Each atom can be in an excited. Exciting atom i requires D_i energy. When atom i is excited, it will give A_i energy. You can excite any number of atoms (including zero).
These atoms also form a peculiar one-way bond. For each i, (1 ≤ i < N), if atom i is excited, atom E_i will also be excited at no cost. Initially, E_i = i+1. Note that atom N cannot form a bond to any atom.
Mr. Chanek must change exactly K bonds. Exactly K times, Mr. Chanek chooses an atom i, (1 ≤ i < N) and changes E_i to a different value other than i and the current E_i. Note that an atom's bond can remain unchanged or changed more than once. Help Mr. Chanek determine the maximum energy that he can achieve!
note: You must first change exactly K bonds before you can start exciting atoms.
Input
The first line contains two integers N K (4 ≤ N ≤ 10^5, 0 ≤ K < N), the number of atoms, and the number of bonds that must be changed.
The second line contains N integers A_i (1 ≤ A_i ≤ 10^6), which denotes the energy given by atom i when on excited state.
The third line contains N integers D_i (1 ≤ D_i ≤ 10^6), which denotes the energy needed to excite atom i.
Output
A line with an integer that denotes the maximum number of energy that Mr. Chanek can get.
Example
Input
6 1
5 6 7 8 10 2
3 5 6 7 1 10
Output
35
Note
An optimal solution to change E_5 to 1 and then excite atom 5 with energy 1. It will cause atoms 1, 2, 3, 4, 5 be excited. The total energy gained by Mr. Chanek is (5 + 6 + 7 + 8 + 10) - 1 = 35.
Another possible way is to change E_3 to 1 and then exciting atom 3 (which will excite atom 1, 2, 3) and exciting atom 4 (which will excite atom 4, 5, 6). The total energy gained by Mr. Chanek is (5 + 6 + 7 + 8 + 10 + 2) - (6 + 7) = 25 which is not optimal.
Submitted Solution:
```
N, K = map(int, input().split())
A = list(map(int, input().split()))
D = list(map(int, input().split()))
suf_sum = A[N-1]
suf_ans = [None]*N
suf_ans[N-1] = max(A[N-1] - D[N-1], 0)
for i in range(N-2, -1, -1):
suf_sum += A[i]
suf_ans[i] = max(suf_ans[i+1], suf_sum-D[i])
# print(i, suf_ans[i])
if K >= 2:
print(max(0, sum(A) - min(*D[:-1]), suf_ans[0]))
exit(0)
if K == 0:
print(max(suf_ans[0], 0))
exit(0)
pre_min = D[0]
pre_sum = 0
ans = 0
for i in range(N-1):
pre_sum += A[i]
pre_min = min(pre_min, D[i])
ans = max(ans, pre_sum - pre_min + suf_ans[i+1])
print(max(0, ans))
``` | instruction | 0 | 70,928 | 3 | 141,856 |
No | output | 1 | 70,928 | 3 | 141,857 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
Throughout Igor K.'s life he has had many situations worthy of attention. We remember the story with the virus, the story of his mathematical career and of course, his famous programming achievements. However, one does not always adopt new hobbies, one can quit something as well.
This time Igor K. got disappointed in one of his hobbies: editing and voicing videos. Moreover, he got disappointed in it so much, that he decided to destroy his secret archive for good.
Igor K. use Pindows XR operation system which represents files and folders by small icons. At that, m icons can fit in a horizontal row in any window.
Igor K.'s computer contains n folders in the D: disk's root catalog. The folders are numbered from 1 to n in the order from the left to the right and from top to bottom (see the images). At that the folders with secret videos have numbers from a to b inclusive. Igor K. wants to delete them forever, at that making as few frame selections as possible, and then pressing Shift+Delete exactly once. What is the minimum number of times Igor K. will have to select the folder in order to select folders from a to b and only them? Let us note that if some selected folder is selected repeatedly, then it is deselected. Each selection possesses the shape of some rectangle with sides parallel to the screen's borders.
Input
The only line contains four integers n, m, a, b (1 ≤ n, m ≤ 109, 1 ≤ a ≤ b ≤ n). They are the number of folders in Igor K.'s computer, the width of a window and the numbers of the first and the last folders that need to be deleted.
Output
Print a single number: the least possible number of times Igor K. will have to select the folders using frames to select only the folders with numbers from a to b.
Examples
Input
11 4 3 9
Output
3
Input
20 5 2 20
Output
2
Note
The images below illustrate statement tests.
The first test:
<image>
In this test we can select folders 3 and 4 with out first selection, folders 5, 6, 7, 8 with our second selection and folder 9 with our third, last selection.
The second test:
<image>
In this test we can first select all folders in the first row (2, 3, 4, 5), then — all other ones.
Submitted Solution:
```
n, m, a, b = map(int, input().split())
a -= 1
b -= 1
ans = 0
if a % m != 0 or b - a < m:
ans += 1
if (b - a - m + a % m) // m > 0:
ans += 1
if b % m != m - 1:
ans += 1
print(ans)
``` | instruction | 0 | 71,363 | 3 | 142,726 |
No | output | 1 | 71,363 | 3 | 142,727 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
Throughout Igor K.'s life he has had many situations worthy of attention. We remember the story with the virus, the story of his mathematical career and of course, his famous programming achievements. However, one does not always adopt new hobbies, one can quit something as well.
This time Igor K. got disappointed in one of his hobbies: editing and voicing videos. Moreover, he got disappointed in it so much, that he decided to destroy his secret archive for good.
Igor K. use Pindows XR operation system which represents files and folders by small icons. At that, m icons can fit in a horizontal row in any window.
Igor K.'s computer contains n folders in the D: disk's root catalog. The folders are numbered from 1 to n in the order from the left to the right and from top to bottom (see the images). At that the folders with secret videos have numbers from a to b inclusive. Igor K. wants to delete them forever, at that making as few frame selections as possible, and then pressing Shift+Delete exactly once. What is the minimum number of times Igor K. will have to select the folder in order to select folders from a to b and only them? Let us note that if some selected folder is selected repeatedly, then it is deselected. Each selection possesses the shape of some rectangle with sides parallel to the screen's borders.
Input
The only line contains four integers n, m, a, b (1 ≤ n, m ≤ 109, 1 ≤ a ≤ b ≤ n). They are the number of folders in Igor K.'s computer, the width of a window and the numbers of the first and the last folders that need to be deleted.
Output
Print a single number: the least possible number of times Igor K. will have to select the folders using frames to select only the folders with numbers from a to b.
Examples
Input
11 4 3 9
Output
3
Input
20 5 2 20
Output
2
Note
The images below illustrate statement tests.
The first test:
<image>
In this test we can select folders 3 and 4 with out first selection, folders 5, 6, 7, 8 with our second selection and folder 9 with our third, last selection.
The second test:
<image>
In this test we can first select all folders in the first row (2, 3, 4, 5), then — all other ones.
Submitted Solution:
```
readints=lambda:map(int, input().strip('\n').split())
n,m,a,b=readints()
a-=1
b-=1 # 0-index
ra=a//m
rb=b//m
ia=a%m
ib=b%m
if ra==rb or (a==0 and b==n-1): # same row
print(1)
else:
mid=rb-1-ra
if ia==0 and ib==m-1:
print(1)
elif ia==0 and ib!=m-1:
print(2)
elif ib==m-1:
print(2)
elif (a-1)==ib:
print(2)
else:
if mid:
print(3)
else:
print(2)
``` | instruction | 0 | 71,364 | 3 | 142,728 |
No | output | 1 | 71,364 | 3 | 142,729 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
Throughout Igor K.'s life he has had many situations worthy of attention. We remember the story with the virus, the story of his mathematical career and of course, his famous programming achievements. However, one does not always adopt new hobbies, one can quit something as well.
This time Igor K. got disappointed in one of his hobbies: editing and voicing videos. Moreover, he got disappointed in it so much, that he decided to destroy his secret archive for good.
Igor K. use Pindows XR operation system which represents files and folders by small icons. At that, m icons can fit in a horizontal row in any window.
Igor K.'s computer contains n folders in the D: disk's root catalog. The folders are numbered from 1 to n in the order from the left to the right and from top to bottom (see the images). At that the folders with secret videos have numbers from a to b inclusive. Igor K. wants to delete them forever, at that making as few frame selections as possible, and then pressing Shift+Delete exactly once. What is the minimum number of times Igor K. will have to select the folder in order to select folders from a to b and only them? Let us note that if some selected folder is selected repeatedly, then it is deselected. Each selection possesses the shape of some rectangle with sides parallel to the screen's borders.
Input
The only line contains four integers n, m, a, b (1 ≤ n, m ≤ 109, 1 ≤ a ≤ b ≤ n). They are the number of folders in Igor K.'s computer, the width of a window and the numbers of the first and the last folders that need to be deleted.
Output
Print a single number: the least possible number of times Igor K. will have to select the folders using frames to select only the folders with numbers from a to b.
Examples
Input
11 4 3 9
Output
3
Input
20 5 2 20
Output
2
Note
The images below illustrate statement tests.
The first test:
<image>
In this test we can select folders 3 and 4 with out first selection, folders 5, 6, 7, 8 with our second selection and folder 9 with our third, last selection.
The second test:
<image>
In this test we can first select all folders in the first row (2, 3, 4, 5), then — all other ones.
Submitted Solution:
```
import sys
from array import array # noqa: F401
def input():
return sys.stdin.buffer.readline().decode('utf-8')
n, m, a, b = map(int, input().split())
a, b = a - 1, b - 1
if a // m == b // m:
print(1)
elif a % m == 0 and b % m == m - 1:
print(1)
elif b % m + 1 == a % m:
print(2)
elif a // m + 1 == b // m:
print(2)
else:
ans = 1 + (a % m != 0) + (b % m != m - 1)
print(ans)
``` | instruction | 0 | 71,365 | 3 | 142,730 |
No | output | 1 | 71,365 | 3 | 142,731 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
Throughout Igor K.'s life he has had many situations worthy of attention. We remember the story with the virus, the story of his mathematical career and of course, his famous programming achievements. However, one does not always adopt new hobbies, one can quit something as well.
This time Igor K. got disappointed in one of his hobbies: editing and voicing videos. Moreover, he got disappointed in it so much, that he decided to destroy his secret archive for good.
Igor K. use Pindows XR operation system which represents files and folders by small icons. At that, m icons can fit in a horizontal row in any window.
Igor K.'s computer contains n folders in the D: disk's root catalog. The folders are numbered from 1 to n in the order from the left to the right and from top to bottom (see the images). At that the folders with secret videos have numbers from a to b inclusive. Igor K. wants to delete them forever, at that making as few frame selections as possible, and then pressing Shift+Delete exactly once. What is the minimum number of times Igor K. will have to select the folder in order to select folders from a to b and only them? Let us note that if some selected folder is selected repeatedly, then it is deselected. Each selection possesses the shape of some rectangle with sides parallel to the screen's borders.
Input
The only line contains four integers n, m, a, b (1 ≤ n, m ≤ 109, 1 ≤ a ≤ b ≤ n). They are the number of folders in Igor K.'s computer, the width of a window and the numbers of the first and the last folders that need to be deleted.
Output
Print a single number: the least possible number of times Igor K. will have to select the folders using frames to select only the folders with numbers from a to b.
Examples
Input
11 4 3 9
Output
3
Input
20 5 2 20
Output
2
Note
The images below illustrate statement tests.
The first test:
<image>
In this test we can select folders 3 and 4 with out first selection, folders 5, 6, 7, 8 with our second selection and folder 9 with our third, last selection.
The second test:
<image>
In this test we can first select all folders in the first row (2, 3, 4, 5), then — all other ones.
Submitted Solution:
```
readints=lambda:map(int, input().strip('\n').split())
n,m,a,b=readints()
a-=1
b-=1 # 0-index
ra=a//m
rb=b//m
ia=a%m
ib=b%m
if ra==rb: # same row
print(1)
else:
mid=rb-1-ra
if ia==0 and ib==m-1:
print(1)
elif ia==0 and ib!=m-1:
print(2)
elif ia!=0 and ib==m-1:
print(2)
elif (a-1)==ib:
print(2)
else:
if mid:
print(3)
else:
print(2)
``` | instruction | 0 | 71,366 | 3 | 142,732 |
No | output | 1 | 71,366 | 3 | 142,733 |
Provide tags and a correct Python 3 solution for this coding contest problem.
This problem is same as the previous one, but has larger constraints.
It was a Sunday morning when the three friends Selena, Shiro and Katie decided to have a trip to the nearby power station (do not try this at home). After arriving at the power station, the cats got impressed with a large power transmission system consisting of many chimneys, electric poles, and wires. Since they are cats, they found those things gigantic.
At the entrance of the station, there is a map describing the complicated wiring system. Selena is the best at math among three friends. He decided to draw the map on the Cartesian plane. Each pole is now a point at some coordinates (x_i, y_i). Since every pole is different, all of the points representing these poles are distinct. Also, every two poles are connected with each other by wires. A wire is a straight line on the plane infinite in both directions. If there are more than two poles lying on the same line, they are connected by a single common wire.
Selena thinks, that whenever two different electric wires intersect, they may interfere with each other and cause damage. So he wonders, how many pairs are intersecting? Could you help him with this problem?
Input
The first line contains a single integer n (2 ≤ n ≤ 1000) — the number of electric poles.
Each of the following n lines contains two integers x_i, y_i (-10^4 ≤ x_i, y_i ≤ 10^4) — the coordinates of the poles.
It is guaranteed that all of these n points are distinct.
Output
Print a single integer — the number of pairs of wires that are intersecting.
Examples
Input
4
0 0
1 1
0 3
1 2
Output
14
Input
4
0 0
0 2
0 4
2 0
Output
6
Input
3
-1 -1
1 0
3 1
Output
0
Note
In the first example:
<image>
In the second example:
<image>
Note that the three poles (0, 0), (0, 2) and (0, 4) are connected by a single wire.
In the third example:
<image> | instruction | 0 | 71,713 | 3 | 143,426 |
Tags: data structures, geometry, implementation, math
Correct Solution:
```
coord = []
coef = {}
a = b = 0
v = {}
coef_a = {}
n = int(input())
for i in range(n):
coord.append(list(map(float, input().split())))
for i in range(n):
x1, y1 = coord[i]
for j in range(i+1,n):
x2, y2 = coord[j]
if x2 - x1: # Ax + By + C, B != 0 (not vert)
a = (y2-y1)/(x2-x1)
b = (y1*x2-y2*x1)/(x2-x1)
coef[(a,b)] = coef.get((a,b),0)+1
coef_a[a] = coef_a.get(a,0)+1
if coef[(a,b)] > 1:
coef[(a,b)] -= 1 # del the same lines
coef_a[a] -= 1
else:
v[x2] = 1
v_nmbr = sum(v.values())
coe = list(coef_a.values())
for i in range(len(coe)):
coe[i] = coe[i]*(coe[i]-1)//2
l_par = sum(coe)
l_nmbr = len(coef) + v_nmbr
ans = l_nmbr*(l_nmbr-1)//2 - v_nmbr*(v_nmbr-1)//2 - l_par
print(ans)
``` | output | 1 | 71,713 | 3 | 143,427 |
Provide tags and a correct Python 3 solution for this coding contest problem.
This problem is same as the previous one, but has larger constraints.
It was a Sunday morning when the three friends Selena, Shiro and Katie decided to have a trip to the nearby power station (do not try this at home). After arriving at the power station, the cats got impressed with a large power transmission system consisting of many chimneys, electric poles, and wires. Since they are cats, they found those things gigantic.
At the entrance of the station, there is a map describing the complicated wiring system. Selena is the best at math among three friends. He decided to draw the map on the Cartesian plane. Each pole is now a point at some coordinates (x_i, y_i). Since every pole is different, all of the points representing these poles are distinct. Also, every two poles are connected with each other by wires. A wire is a straight line on the plane infinite in both directions. If there are more than two poles lying on the same line, they are connected by a single common wire.
Selena thinks, that whenever two different electric wires intersect, they may interfere with each other and cause damage. So he wonders, how many pairs are intersecting? Could you help him with this problem?
Input
The first line contains a single integer n (2 ≤ n ≤ 1000) — the number of electric poles.
Each of the following n lines contains two integers x_i, y_i (-10^4 ≤ x_i, y_i ≤ 10^4) — the coordinates of the poles.
It is guaranteed that all of these n points are distinct.
Output
Print a single integer — the number of pairs of wires that are intersecting.
Examples
Input
4
0 0
1 1
0 3
1 2
Output
14
Input
4
0 0
0 2
0 4
2 0
Output
6
Input
3
-1 -1
1 0
3 1
Output
0
Note
In the first example:
<image>
In the second example:
<image>
Note that the three poles (0, 0), (0, 2) and (0, 4) are connected by a single wire.
In the third example:
<image> | instruction | 0 | 71,715 | 3 | 143,430 |
Tags: data structures, geometry, implementation, math
Correct Solution:
```
#Bhargey Mehta (Sophomore)
#DA-IICT, Gandhinagar
import sys, math, queue
#sys.stdin = open("input.txt", "r")
MOD = 10**9+7
n = int(input())
p = []
for i in range(n):
x, y = map(int, input().split())
p.append((x, y))
d = {}
for i in range(n):
x1, y1 = p[i]
for j in range(i+1, n):
x2, y2 = p[j]
if x1 != x2:
m = (y2-y1)/(x2-x1)
c = (y1*x2-x1*y2)/(x2-x1)
else:
m = 10**10
c = x1
if m in d:
if c in d[m]:
d[m][c] += 1
else:
d[m][c] = 1
else:
d[m] = {c: 1}
p = []
for m in d:
p.append(len(d[m]))
s = sum(p)
ans = 0
for x in p:
ans += x*(s-x)
print(ans//2)
``` | output | 1 | 71,715 | 3 | 143,431 |
Provide tags and a correct Python 3 solution for this coding contest problem.
This problem is same as the previous one, but has larger constraints.
It was a Sunday morning when the three friends Selena, Shiro and Katie decided to have a trip to the nearby power station (do not try this at home). After arriving at the power station, the cats got impressed with a large power transmission system consisting of many chimneys, electric poles, and wires. Since they are cats, they found those things gigantic.
At the entrance of the station, there is a map describing the complicated wiring system. Selena is the best at math among three friends. He decided to draw the map on the Cartesian plane. Each pole is now a point at some coordinates (x_i, y_i). Since every pole is different, all of the points representing these poles are distinct. Also, every two poles are connected with each other by wires. A wire is a straight line on the plane infinite in both directions. If there are more than two poles lying on the same line, they are connected by a single common wire.
Selena thinks, that whenever two different electric wires intersect, they may interfere with each other and cause damage. So he wonders, how many pairs are intersecting? Could you help him with this problem?
Input
The first line contains a single integer n (2 ≤ n ≤ 1000) — the number of electric poles.
Each of the following n lines contains two integers x_i, y_i (-10^4 ≤ x_i, y_i ≤ 10^4) — the coordinates of the poles.
It is guaranteed that all of these n points are distinct.
Output
Print a single integer — the number of pairs of wires that are intersecting.
Examples
Input
4
0 0
1 1
0 3
1 2
Output
14
Input
4
0 0
0 2
0 4
2 0
Output
6
Input
3
-1 -1
1 0
3 1
Output
0
Note
In the first example:
<image>
In the second example:
<image>
Note that the three poles (0, 0), (0, 2) and (0, 4) are connected by a single wire.
In the third example:
<image> | instruction | 0 | 71,716 | 3 | 143,432 |
Tags: data structures, geometry, implementation, math
Correct Solution:
```
import sys
input=sys.stdin.readline
from math import gcd
n=int(input())
p=[list(map(int,input().split())) for i in range(n)]
lines=[]
for i in range(n):
x1,y1=p[i]
for j in range(i+1,n):
x2,y2=p[j]
# a*x-b*y=c
a=y1-y2
b=x1-x2
c=y1*x2-x1*y2
if a<0 or (a==0 and b<0):
a=-a;b=-b;c=-c
g=gcd(a,gcd(b,c))
a//=g;b//=g;c//=g
lines.append((a,b,c))
lines=list(set(lines)) # remove duplicate
m=len(lines)
lines.sort(key=lambda x:x[1]/max(x[0],10**(-10)))
cnt=1
ans=m*(m-1)//2
for i in range(m-1):
a1,b1,c1=lines[i]
a2,b2,c2=lines[i+1]
if a1*b2-a2*b1==0:
cnt+=1
else:
ans-=cnt*(cnt-1)//2
cnt=1
ans-=cnt*(cnt-1)//2
print(ans)
``` | output | 1 | 71,716 | 3 | 143,433 |
Provide tags and a correct Python 3 solution for this coding contest problem.
This problem is same as the previous one, but has larger constraints.
It was a Sunday morning when the three friends Selena, Shiro and Katie decided to have a trip to the nearby power station (do not try this at home). After arriving at the power station, the cats got impressed with a large power transmission system consisting of many chimneys, electric poles, and wires. Since they are cats, they found those things gigantic.
At the entrance of the station, there is a map describing the complicated wiring system. Selena is the best at math among three friends. He decided to draw the map on the Cartesian plane. Each pole is now a point at some coordinates (x_i, y_i). Since every pole is different, all of the points representing these poles are distinct. Also, every two poles are connected with each other by wires. A wire is a straight line on the plane infinite in both directions. If there are more than two poles lying on the same line, they are connected by a single common wire.
Selena thinks, that whenever two different electric wires intersect, they may interfere with each other and cause damage. So he wonders, how many pairs are intersecting? Could you help him with this problem?
Input
The first line contains a single integer n (2 ≤ n ≤ 1000) — the number of electric poles.
Each of the following n lines contains two integers x_i, y_i (-10^4 ≤ x_i, y_i ≤ 10^4) — the coordinates of the poles.
It is guaranteed that all of these n points are distinct.
Output
Print a single integer — the number of pairs of wires that are intersecting.
Examples
Input
4
0 0
1 1
0 3
1 2
Output
14
Input
4
0 0
0 2
0 4
2 0
Output
6
Input
3
-1 -1
1 0
3 1
Output
0
Note
In the first example:
<image>
In the second example:
<image>
Note that the three poles (0, 0), (0, 2) and (0, 4) are connected by a single wire.
In the third example:
<image> | instruction | 0 | 71,718 | 3 | 143,436 |
Tags: data structures, geometry, implementation, math
Correct Solution:
```
from sys import stdin,stdout
import math
from itertools import accumulate
def getabc(x1,y1,x2,y2):
t1=x2-x1;t2=y2-y1;t3=y1*x2-y2*x1
if t1<0:
t1=t1*(-1);t2=t2*(-1);t3=t3*(-1)
t4=math.gcd(math.gcd(t1,t2),t3)
return t1//t4,t2//t4,t3//t4
n=int(stdin.readline())
x=[];y=[]
for i in range(n):
xi,yi=stdin.readline().strip().split(' ')
x.append(int(xi));y.append(int(yi))
d={}
there={}
for i in range(len(x)):
for j in range(i+1,len(x)):
num=y[i]-y[j]
den=x[i]-x[j]
if num==0:
key='yintercept'+str(y[i])
if key not in d:
d[key]=1
elif den==0:
key='xintercept'+str(x[i])
if key not in d:
d[key]=1
else:
a,b,c=getabc(x[i],y[i],x[j],y[j])
key=str(a)+' '+str(b)+' '+str(c)
keys=str(a)+' '+str(b)
if key not in there:
if keys in d:
d[keys]+=1
else:
d[keys]=1
there[key]=1
ansarr=[0,0] # [lines parallel to y-axis , lines parallel to x axis]
for i in d:
if i[0]=='x':
ansarr[0]+=1
elif i[0]=='y':
ansarr[1]+=1
else:
ansarr.append(d[i])
ans=0;
tarr=sum(ansarr)
for i in range(len(ansarr)):
ans+=(tarr-ansarr[i])*ansarr[i]
stdout.write(str(ans//2)+'\n')
``` | output | 1 | 71,718 | 3 | 143,437 |
Provide tags and a correct Python 3 solution for this coding contest problem.
This problem is same as the previous one, but has larger constraints.
It was a Sunday morning when the three friends Selena, Shiro and Katie decided to have a trip to the nearby power station (do not try this at home). After arriving at the power station, the cats got impressed with a large power transmission system consisting of many chimneys, electric poles, and wires. Since they are cats, they found those things gigantic.
At the entrance of the station, there is a map describing the complicated wiring system. Selena is the best at math among three friends. He decided to draw the map on the Cartesian plane. Each pole is now a point at some coordinates (x_i, y_i). Since every pole is different, all of the points representing these poles are distinct. Also, every two poles are connected with each other by wires. A wire is a straight line on the plane infinite in both directions. If there are more than two poles lying on the same line, they are connected by a single common wire.
Selena thinks, that whenever two different electric wires intersect, they may interfere with each other and cause damage. So he wonders, how many pairs are intersecting? Could you help him with this problem?
Input
The first line contains a single integer n (2 ≤ n ≤ 1000) — the number of electric poles.
Each of the following n lines contains two integers x_i, y_i (-10^4 ≤ x_i, y_i ≤ 10^4) — the coordinates of the poles.
It is guaranteed that all of these n points are distinct.
Output
Print a single integer — the number of pairs of wires that are intersecting.
Examples
Input
4
0 0
1 1
0 3
1 2
Output
14
Input
4
0 0
0 2
0 4
2 0
Output
6
Input
3
-1 -1
1 0
3 1
Output
0
Note
In the first example:
<image>
In the second example:
<image>
Note that the three poles (0, 0), (0, 2) and (0, 4) are connected by a single wire.
In the third example:
<image> | instruction | 0 | 71,719 | 3 | 143,438 |
Tags: data structures, geometry, implementation, math
Correct Solution:
```
from functools import reduce
from math import gcd
import collections
gcdm = lambda *args: reduce(gcd, args, 0)
def pointsToLine2d(p1, p2):
if p1 == p2:
return (0, 0, 0)
_p1, _p2 = sorted((p1, p2))
g = gcdm(*filter(lambda x: x != 0, (_p2[1] - _p1[1], _p1[0] - _p2[0], _p1[1] * _p2[0] - _p1[0] * _p2[1])))
return ((_p2[1] - _p1[1]) // g, (_p1[0] - _p2[0]) // g, (_p1[1] * _p2[0] - _p1[0] * _p2[1]) // g)
def main():
from sys import stdin, stdout
def read():
return stdin.readline().rstrip('\n')
def read_array(sep=None, maxsplit=-1):
return read().split(sep, maxsplit)
def read_int():
return int(read())
def read_int_array(sep=None, maxsplit=-1):
return [int(a) for a in read_array(sep, maxsplit)]
def write(*args, **kwargs):
sep = kwargs.get('sep', ' ')
end = kwargs.get('end', '\n')
stdout.write(sep.join(str(a) for a in args) + end)
def write_array(array, **kwargs):
sep = kwargs.get('sep', ' ')
end = kwargs.get('end', '\n')
stdout.write(sep.join(str(a) for a in array) + end)
n = read_int()
p = []
for _ in range(n):
p.append(read_int_array())
lines = set()
for i in range(n):
for j in range(i+1, n):
lines.add(pointsToLine2d(p[i], p[j]))
k = len(lines)
ax_bx = collections.defaultdict(int)
out = 0
for a, b, _ in lines:
ax_bx[a, b] += 1
for x in ax_bx.values():
out += (k - x) * x
write(out // 2)
main()
``` | output | 1 | 71,719 | 3 | 143,439 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
This problem is same as the previous one, but has larger constraints.
It was a Sunday morning when the three friends Selena, Shiro and Katie decided to have a trip to the nearby power station (do not try this at home). After arriving at the power station, the cats got impressed with a large power transmission system consisting of many chimneys, electric poles, and wires. Since they are cats, they found those things gigantic.
At the entrance of the station, there is a map describing the complicated wiring system. Selena is the best at math among three friends. He decided to draw the map on the Cartesian plane. Each pole is now a point at some coordinates (x_i, y_i). Since every pole is different, all of the points representing these poles are distinct. Also, every two poles are connected with each other by wires. A wire is a straight line on the plane infinite in both directions. If there are more than two poles lying on the same line, they are connected by a single common wire.
Selena thinks, that whenever two different electric wires intersect, they may interfere with each other and cause damage. So he wonders, how many pairs are intersecting? Could you help him with this problem?
Input
The first line contains a single integer n (2 ≤ n ≤ 1000) — the number of electric poles.
Each of the following n lines contains two integers x_i, y_i (-10^4 ≤ x_i, y_i ≤ 10^4) — the coordinates of the poles.
It is guaranteed that all of these n points are distinct.
Output
Print a single integer — the number of pairs of wires that are intersecting.
Examples
Input
4
0 0
1 1
0 3
1 2
Output
14
Input
4
0 0
0 2
0 4
2 0
Output
6
Input
3
-1 -1
1 0
3 1
Output
0
Note
In the first example:
<image>
In the second example:
<image>
Note that the three poles (0, 0), (0, 2) and (0, 4) are connected by a single wire.
In the third example:
<image>
Submitted Solution:
```
from math import *
class slopeC:
def __init__(self):
self.chil = set()
n = int(input())
slopes = {}
L = []
for i in range(n):
x, y = map(int, input().split())
for l in L:
if x != l[0]:
slope = (y - l[1]) / (x - l[0])
else:
slope = inf
s1 = str(l[0]) + '-' + str(l[1])
s2 = str(x) + '-' + str(y)
if slope not in slopes:
slopes[slope] = [slopeC()]
slopes[slope][0].chil.add(s1)
slopes[slope][0].chil.add(s2)
else:
f = 0
for child in slopes[slope]:
if s1 in child.chil:
f = 1
child.chil.add(s2)
break
if f == 0:
slopes[slope] += [slopeC()]
slopes[slope][0].chil.add(s1)
slopes[slope][0].chil.add(s2)
L += [[x, y]]
A = []
P = [0]
for s in slopes:
A += [(len(slopes[s]))]
P += [P[-1] + A[-1]]
ans = 0
for i, v in enumerate(A):
ans += A[i] * (P[-1] - P[i+1])
print(ans)
``` | instruction | 0 | 71,720 | 3 | 143,440 |
Yes | output | 1 | 71,720 | 3 | 143,441 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
This problem is same as the previous one, but has larger constraints.
It was a Sunday morning when the three friends Selena, Shiro and Katie decided to have a trip to the nearby power station (do not try this at home). After arriving at the power station, the cats got impressed with a large power transmission system consisting of many chimneys, electric poles, and wires. Since they are cats, they found those things gigantic.
At the entrance of the station, there is a map describing the complicated wiring system. Selena is the best at math among three friends. He decided to draw the map on the Cartesian plane. Each pole is now a point at some coordinates (x_i, y_i). Since every pole is different, all of the points representing these poles are distinct. Also, every two poles are connected with each other by wires. A wire is a straight line on the plane infinite in both directions. If there are more than two poles lying on the same line, they are connected by a single common wire.
Selena thinks, that whenever two different electric wires intersect, they may interfere with each other and cause damage. So he wonders, how many pairs are intersecting? Could you help him with this problem?
Input
The first line contains a single integer n (2 ≤ n ≤ 1000) — the number of electric poles.
Each of the following n lines contains two integers x_i, y_i (-10^4 ≤ x_i, y_i ≤ 10^4) — the coordinates of the poles.
It is guaranteed that all of these n points are distinct.
Output
Print a single integer — the number of pairs of wires that are intersecting.
Examples
Input
4
0 0
1 1
0 3
1 2
Output
14
Input
4
0 0
0 2
0 4
2 0
Output
6
Input
3
-1 -1
1 0
3 1
Output
0
Note
In the first example:
<image>
In the second example:
<image>
Note that the three poles (0, 0), (0, 2) and (0, 4) are connected by a single wire.
In the third example:
<image>
Submitted Solution:
```
from collections import Counter
from sys import exit
N = int(input())
if N == 2:
print(0)
exit()
inf = 10**9+7
inf2 = 10**18
def gcdl(A):
if len(A) == 0:
return -1
if len(A) == 1:
return 0
g = gcd(A[0], A[1])
for a in A[2:]:
g = gcd(a, g)
return g
def gcd(a,b):
if b == 0:
return a
return gcd(b,a%b)
Point = []
ans = 0
for _ in range(N):
Point.append(list(map(int, input().split())))
S = Counter()
T = set()
for i in range(N):
x1 , y1 = Point[i]
for j in range(N):
if i == j:
continue
x2 , y2 = Point[j]
a = y1 - y2
b = -(x1 - x2)
c = x2*y1 - x1*y2
g = gcdl([a, b, c])
a //= g
b //= g
c //= g
if a < 0:
a *= -1
b *= -1
c *= -1
k = a*inf+b*inf2+c
if k not in T:
T.add(a*inf+b*inf2+c)
if x1 == x2:
S[-1] += 1
else:
y = y1 - y2
x = x1 - x2
g = gcd(y, x)
y //= g
x //= g
if y < 0:
y *= -1
x *= -1
S[y*inf+x] += 1
L = len(T)
ans = L*(L-1)//2
for s in S.values():
ans -= s*(s-1)//2
print(ans)
``` | instruction | 0 | 71,721 | 3 | 143,442 |
Yes | output | 1 | 71,721 | 3 | 143,443 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
This problem is same as the previous one, but has larger constraints.
It was a Sunday morning when the three friends Selena, Shiro and Katie decided to have a trip to the nearby power station (do not try this at home). After arriving at the power station, the cats got impressed with a large power transmission system consisting of many chimneys, electric poles, and wires. Since they are cats, they found those things gigantic.
At the entrance of the station, there is a map describing the complicated wiring system. Selena is the best at math among three friends. He decided to draw the map on the Cartesian plane. Each pole is now a point at some coordinates (x_i, y_i). Since every pole is different, all of the points representing these poles are distinct. Also, every two poles are connected with each other by wires. A wire is a straight line on the plane infinite in both directions. If there are more than two poles lying on the same line, they are connected by a single common wire.
Selena thinks, that whenever two different electric wires intersect, they may interfere with each other and cause damage. So he wonders, how many pairs are intersecting? Could you help him with this problem?
Input
The first line contains a single integer n (2 ≤ n ≤ 1000) — the number of electric poles.
Each of the following n lines contains two integers x_i, y_i (-10^4 ≤ x_i, y_i ≤ 10^4) — the coordinates of the poles.
It is guaranteed that all of these n points are distinct.
Output
Print a single integer — the number of pairs of wires that are intersecting.
Examples
Input
4
0 0
1 1
0 3
1 2
Output
14
Input
4
0 0
0 2
0 4
2 0
Output
6
Input
3
-1 -1
1 0
3 1
Output
0
Note
In the first example:
<image>
In the second example:
<image>
Note that the three poles (0, 0), (0, 2) and (0, 4) are connected by a single wire.
In the third example:
<image>
Submitted Solution:
```
from math import gcd
n = int(input())
P = [[int(x) for x in input().split()] for _ in range(n)]
L = []
def addLine(x,y,dx,dy):
if dx < 0:
dx *= -1
dy *= -1
elif dx == 0:
if dy < 0:
dy *= -1
g = gcd(dx,dy)
dx //= g
dy //= g
x += dx * (10**9)
y += dy * (10**9)
if dx:
k = x//dx
else:
k = y//dy
x -= k*dx
y -= k*dy
L.append((x,y,dx,dy))
for i in range(n):
for j in range(i+1,n):
xi,yi = P[i]
xj,yj = P[j]
dx,dy = xi-xj,yi-yj
addLine(xi,yi,dx,dy)
from collections import defaultdict as dd, deque
L = list(set(L))
res = 0
C = dd(int)
for x,y,dx,dy in L:
C[dx,dy] += 1
ss = sum(C.values())
for x in C.values():
res += (ss-x)*x
#for i in range(len(L)):
# for j in range(i+1, len(L)):
# x1,y1,dx1,dy1 = L[i]
# x2,y2,dx2,dy2 = L[j]
# if dx1 != dx2 or dy1 != dy2:
# #print(L[i])
# #print(L[j])
# #print('---')
# res += 1
print(res//2)
``` | instruction | 0 | 71,722 | 3 | 143,444 |
Yes | output | 1 | 71,722 | 3 | 143,445 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
This problem is same as the previous one, but has larger constraints.
It was a Sunday morning when the three friends Selena, Shiro and Katie decided to have a trip to the nearby power station (do not try this at home). After arriving at the power station, the cats got impressed with a large power transmission system consisting of many chimneys, electric poles, and wires. Since they are cats, they found those things gigantic.
At the entrance of the station, there is a map describing the complicated wiring system. Selena is the best at math among three friends. He decided to draw the map on the Cartesian plane. Each pole is now a point at some coordinates (x_i, y_i). Since every pole is different, all of the points representing these poles are distinct. Also, every two poles are connected with each other by wires. A wire is a straight line on the plane infinite in both directions. If there are more than two poles lying on the same line, they are connected by a single common wire.
Selena thinks, that whenever two different electric wires intersect, they may interfere with each other and cause damage. So he wonders, how many pairs are intersecting? Could you help him with this problem?
Input
The first line contains a single integer n (2 ≤ n ≤ 1000) — the number of electric poles.
Each of the following n lines contains two integers x_i, y_i (-10^4 ≤ x_i, y_i ≤ 10^4) — the coordinates of the poles.
It is guaranteed that all of these n points are distinct.
Output
Print a single integer — the number of pairs of wires that are intersecting.
Examples
Input
4
0 0
1 1
0 3
1 2
Output
14
Input
4
0 0
0 2
0 4
2 0
Output
6
Input
3
-1 -1
1 0
3 1
Output
0
Note
In the first example:
<image>
In the second example:
<image>
Note that the three poles (0, 0), (0, 2) and (0, 4) are connected by a single wire.
In the third example:
<image>
Submitted Solution:
```
from functools import reduce
from math import gcd
import collections
gcdm = lambda *args: reduce(gcd, args, 0)
def pointsToLine2d(p1, p2):
if p1 == p2:
return 0, 0, 0
p1, p2 = sorted((p1, p2))
a, b, c = p2[1] - p1[1], p1[0] - p2[0], p1[1] * p2[0] - p1[0] * p2[1]
g = gcdm(*filter(lambda x: x != 0, (a, b, c)))
return a // g, b // g, c // g
def main():
from sys import stdin, stdout
def read():
return stdin.readline().rstrip('\n')
def read_array(sep=None, maxsplit=-1):
return read().split(sep, maxsplit)
def read_int():
return int(read())
def read_int_array(sep=None, maxsplit=-1):
return [int(a) for a in read_array(sep, maxsplit)]
def write(*args, **kwargs):
sep = kwargs.get('sep', ' ')
end = kwargs.get('end', '\n')
stdout.write(sep.join(str(a) for a in args) + end)
def write_array(array, **kwargs):
sep = kwargs.get('sep', ' ')
end = kwargs.get('end', '\n')
stdout.write(sep.join(str(a) for a in array) + end)
n = read_int()
p = []
for _ in range(n):
p.append(read_int_array())
lines = set()
for i in range(n):
for j in range(i+1, n):
lines.add(pointsToLine2d(p[i], p[j]))
k = len(lines)
ax_bx = collections.defaultdict(int)
out = 0
for a, b, _ in lines:
ax_bx[a, b] += 1
for x in ax_bx.values():
out += (k - x) * x
write(out // 2)
main()
``` | instruction | 0 | 71,723 | 3 | 143,446 |
Yes | output | 1 | 71,723 | 3 | 143,447 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
This problem is same as the previous one, but has larger constraints.
It was a Sunday morning when the three friends Selena, Shiro and Katie decided to have a trip to the nearby power station (do not try this at home). After arriving at the power station, the cats got impressed with a large power transmission system consisting of many chimneys, electric poles, and wires. Since they are cats, they found those things gigantic.
At the entrance of the station, there is a map describing the complicated wiring system. Selena is the best at math among three friends. He decided to draw the map on the Cartesian plane. Each pole is now a point at some coordinates (x_i, y_i). Since every pole is different, all of the points representing these poles are distinct. Also, every two poles are connected with each other by wires. A wire is a straight line on the plane infinite in both directions. If there are more than two poles lying on the same line, they are connected by a single common wire.
Selena thinks, that whenever two different electric wires intersect, they may interfere with each other and cause damage. So he wonders, how many pairs are intersecting? Could you help him with this problem?
Input
The first line contains a single integer n (2 ≤ n ≤ 1000) — the number of electric poles.
Each of the following n lines contains two integers x_i, y_i (-10^4 ≤ x_i, y_i ≤ 10^4) — the coordinates of the poles.
It is guaranteed that all of these n points are distinct.
Output
Print a single integer — the number of pairs of wires that are intersecting.
Examples
Input
4
0 0
1 1
0 3
1 2
Output
14
Input
4
0 0
0 2
0 4
2 0
Output
6
Input
3
-1 -1
1 0
3 1
Output
0
Note
In the first example:
<image>
In the second example:
<image>
Note that the three poles (0, 0), (0, 2) and (0, 4) are connected by a single wire.
In the third example:
<image>
Submitted Solution:
```
lines = set()
points = []
num = int(input())
for i in range(num):
points.append([int(j) for j in input().split()])
for i in range(num):
for j in range(i):
dx = (points[j][0] - points[i][0])
if dx == 0:
lines.add((11932912953213, points[i][0]))
else:
m = (points[j][1] - points[i][1])/dx
lines.add((int((11000000000)*m), int((1100000000000)*(points[i][1] - m * points[i][0]))))
ms = {}
for l in lines:
if l[0] in ms:
ms[l[0]] += 1
else:
ms[l[0]] = 1
total = 0
#print(lines)
#print(ms)
#print(type(ms.values()))
t = list(ms.values())
s = sum(t)
for a in t:
total += a * (s-a)
print(total//2)
``` | instruction | 0 | 71,724 | 3 | 143,448 |
No | output | 1 | 71,724 | 3 | 143,449 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
This problem is same as the previous one, but has larger constraints.
It was a Sunday morning when the three friends Selena, Shiro and Katie decided to have a trip to the nearby power station (do not try this at home). After arriving at the power station, the cats got impressed with a large power transmission system consisting of many chimneys, electric poles, and wires. Since they are cats, they found those things gigantic.
At the entrance of the station, there is a map describing the complicated wiring system. Selena is the best at math among three friends. He decided to draw the map on the Cartesian plane. Each pole is now a point at some coordinates (x_i, y_i). Since every pole is different, all of the points representing these poles are distinct. Also, every two poles are connected with each other by wires. A wire is a straight line on the plane infinite in both directions. If there are more than two poles lying on the same line, they are connected by a single common wire.
Selena thinks, that whenever two different electric wires intersect, they may interfere with each other and cause damage. So he wonders, how many pairs are intersecting? Could you help him with this problem?
Input
The first line contains a single integer n (2 ≤ n ≤ 1000) — the number of electric poles.
Each of the following n lines contains two integers x_i, y_i (-10^4 ≤ x_i, y_i ≤ 10^4) — the coordinates of the poles.
It is guaranteed that all of these n points are distinct.
Output
Print a single integer — the number of pairs of wires that are intersecting.
Examples
Input
4
0 0
1 1
0 3
1 2
Output
14
Input
4
0 0
0 2
0 4
2 0
Output
6
Input
3
-1 -1
1 0
3 1
Output
0
Note
In the first example:
<image>
In the second example:
<image>
Note that the three poles (0, 0), (0, 2) and (0, 4) are connected by a single wire.
In the third example:
<image>
Submitted Solution:
```
from collections import *
def li():return [int(i) for i in input().split()]
def val():return int(input())
n = val()
l = []
for i in range(n):l.append(li())
d = defaultdict(int)
tot = 1
tottillnow = 0
visited = set()
for i in range(n):
for j in range(i):
tottillnow += 1
try:
slope = (l[i][1] - l[j][1])/(l[i][0] - l[j][0])
except:
slope = 'inf'
if slope == 'inf':
intercept = l[j][0]
else:
intercept = l[j][0]*slope - l[j][1]
if tuple([slope,intercept]) not in visited:
d[slope] += 1
visited.add(tuple([slope,intercept]))
tot = sum(d.values())
ans = 0
for i in d:
ans += (tot - d[i])*(d[i])
print(ans//2)
``` | instruction | 0 | 71,725 | 3 | 143,450 |
No | output | 1 | 71,725 | 3 | 143,451 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
This problem is same as the previous one, but has larger constraints.
It was a Sunday morning when the three friends Selena, Shiro and Katie decided to have a trip to the nearby power station (do not try this at home). After arriving at the power station, the cats got impressed with a large power transmission system consisting of many chimneys, electric poles, and wires. Since they are cats, they found those things gigantic.
At the entrance of the station, there is a map describing the complicated wiring system. Selena is the best at math among three friends. He decided to draw the map on the Cartesian plane. Each pole is now a point at some coordinates (x_i, y_i). Since every pole is different, all of the points representing these poles are distinct. Also, every two poles are connected with each other by wires. A wire is a straight line on the plane infinite in both directions. If there are more than two poles lying on the same line, they are connected by a single common wire.
Selena thinks, that whenever two different electric wires intersect, they may interfere with each other and cause damage. So he wonders, how many pairs are intersecting? Could you help him with this problem?
Input
The first line contains a single integer n (2 ≤ n ≤ 1000) — the number of electric poles.
Each of the following n lines contains two integers x_i, y_i (-10^4 ≤ x_i, y_i ≤ 10^4) — the coordinates of the poles.
It is guaranteed that all of these n points are distinct.
Output
Print a single integer — the number of pairs of wires that are intersecting.
Examples
Input
4
0 0
1 1
0 3
1 2
Output
14
Input
4
0 0
0 2
0 4
2 0
Output
6
Input
3
-1 -1
1 0
3 1
Output
0
Note
In the first example:
<image>
In the second example:
<image>
Note that the three poles (0, 0), (0, 2) and (0, 4) are connected by a single wire.
In the third example:
<image>
Submitted Solution:
```
lines = set()
points = []
num = int(input())
for i in range(num):
points.append([int(j) for j in input().split()])
for i in range(num):
for j in range(i):
dx = (points[j][0] - points[i][0])
if dx == 0:
lines.add((11932912953213, points[i][0]))
else:
m = (points[j][1] - points[i][1])/dx
lines.add((int((11000000000)*m), int((11000000000)*(points[i][1] - m * points[i][0]))))
ms = {}
for l in lines:
if l[0] in ms:
ms[l[0]] += 1
else:
ms[l[0]] = 1
total = 0
#print(lines)
#print(ms)
#print(type(ms.values()))
t = list(ms.values())
s = sum(t)
for a in t:
total += a * (s-a)
print(total//2)
``` | instruction | 0 | 71,726 | 3 | 143,452 |
No | output | 1 | 71,726 | 3 | 143,453 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
This problem is same as the previous one, but has larger constraints.
It was a Sunday morning when the three friends Selena, Shiro and Katie decided to have a trip to the nearby power station (do not try this at home). After arriving at the power station, the cats got impressed with a large power transmission system consisting of many chimneys, electric poles, and wires. Since they are cats, they found those things gigantic.
At the entrance of the station, there is a map describing the complicated wiring system. Selena is the best at math among three friends. He decided to draw the map on the Cartesian plane. Each pole is now a point at some coordinates (x_i, y_i). Since every pole is different, all of the points representing these poles are distinct. Also, every two poles are connected with each other by wires. A wire is a straight line on the plane infinite in both directions. If there are more than two poles lying on the same line, they are connected by a single common wire.
Selena thinks, that whenever two different electric wires intersect, they may interfere with each other and cause damage. So he wonders, how many pairs are intersecting? Could you help him with this problem?
Input
The first line contains a single integer n (2 ≤ n ≤ 1000) — the number of electric poles.
Each of the following n lines contains two integers x_i, y_i (-10^4 ≤ x_i, y_i ≤ 10^4) — the coordinates of the poles.
It is guaranteed that all of these n points are distinct.
Output
Print a single integer — the number of pairs of wires that are intersecting.
Examples
Input
4
0 0
1 1
0 3
1 2
Output
14
Input
4
0 0
0 2
0 4
2 0
Output
6
Input
3
-1 -1
1 0
3 1
Output
0
Note
In the first example:
<image>
In the second example:
<image>
Note that the three poles (0, 0), (0, 2) and (0, 4) are connected by a single wire.
In the third example:
<image>
Submitted Solution:
```
# ------------------- fast io --------------------
import os
import sys
from io import BytesIO, IOBase
BUFSIZE = 8192
class FastIO(IOBase):
newlines = 0
def __init__(self, file):
self._fd = file.fileno()
self.buffer = BytesIO()
self.writable = "x" in file.mode or "r" not in file.mode
self.write = self.buffer.write if self.writable else None
def read(self):
while True:
b = os.read(self._fd, max(os.fstat(self._fd).st_size, BUFSIZE))
if not b:
break
ptr = self.buffer.tell()
self.buffer.seek(0, 2), self.buffer.write(b), self.buffer.seek(ptr)
self.newlines = 0
return self.buffer.read()
def readline(self):
while self.newlines == 0:
b = os.read(self._fd, max(os.fstat(self._fd).st_size, BUFSIZE))
self.newlines = b.count(b"\n") + (not b)
ptr = self.buffer.tell()
self.buffer.seek(0, 2), self.buffer.write(b), self.buffer.seek(ptr)
self.newlines -= 1
return self.buffer.readline()
def flush(self):
if self.writable:
os.write(self._fd, self.buffer.getvalue())
self.buffer.truncate(0), self.buffer.seek(0)
class IOWrapper(IOBase):
def __init__(self, file):
self.buffer = FastIO(file)
self.flush = self.buffer.flush
self.writable = self.buffer.writable
self.write = lambda s: self.buffer.write(s.encode("ascii"))
self.read = lambda: self.buffer.read().decode("ascii")
self.readline = lambda: self.buffer.readline().decode("ascii")
sys.stdin, sys.stdout = IOWrapper(sys.stdin), IOWrapper(sys.stdout)
input = lambda: sys.stdin.readline().rstrip("\r\n")
# ------------------- fast io --------------------
from math import gcd, ceil
def pre(s):
n = len(s)
pi = [0] * n
for i in range(1, n):
j = pi[i - 1]
while j and s[i] != s[j]:
j = pi[j - 1]
if s[i] == s[j]:
j += 1
pi[i] = j
return pi
def prod(a):
ans = 1
for each in a:
ans = (ans * each)
return ans
def lcm(a, b): return a * b // gcd(a, b)
def binary(x, length=16):
y = bin(x)[2:]
return y if len(y) >= length else "0" * (length - len(y)) + y
pts = []
for _ in range(int(input()) if True else 1):
x, y = map(int, input().split())
pts += [[x,y]]
ps = []
pss = set()
from fractions import Fraction
for i in range(len(pts)-1):
for j in range(i+1, len(pts)):
x1, y1, x2, y2 = pts[i][0], pts[i][1], pts[j][0], pts[j][1]
#ax+by+c=0
a,b,c=y1-y2, x2-x1, x1*y2-x2*y1
g = gcd(a,b)
a, b = a//g, b//g
c = str(Fraction(c, g))
xx = str(a) + ","+str(b)+","+str(c)
if xx not in pss:
pss.add(xx)
ps += [[a,b,c]]
ans = len(ps) * (len(ps) - 1) // 2
di={}
for i in ps:
xx = str(i[0])+","+str(i[1])
if xx in di:
di[xx] += 1
else:
di[xx] = 1
for i in di:
ans -= di[i] * (di[i] - 1) // 2
print(ans)
``` | instruction | 0 | 71,727 | 3 | 143,454 |
No | output | 1 | 71,727 | 3 | 143,455 |
Provide tags and a correct Python 3 solution for this coding contest problem.
Being tired of participating in too many Codeforces rounds, Gildong decided to take some rest in a park. He sat down on a bench, and soon he found two rabbits hopping around. One of the rabbits was taller than the other.
He noticed that the two rabbits were hopping towards each other. The positions of the two rabbits can be represented as integer coordinates on a horizontal line. The taller rabbit is currently on position x, and the shorter rabbit is currently on position y (x < y). Every second, each rabbit hops to another position. The taller rabbit hops to the positive direction by a, and the shorter rabbit hops to the negative direction by b.
<image>
For example, let's say x=0, y=10, a=2, and b=3. At the 1-st second, each rabbit will be at position 2 and 7. At the 2-nd second, both rabbits will be at position 4.
Gildong is now wondering: Will the two rabbits be at the same position at the same moment? If so, how long will it take? Let's find a moment in time (in seconds) after which the rabbits will be at the same point.
Input
Each test contains one or more test cases. The first line contains the number of test cases t (1 ≤ t ≤ 1000).
Each test case contains exactly one line. The line consists of four integers x, y, a, b (0 ≤ x < y ≤ 10^9, 1 ≤ a,b ≤ 10^9) — the current position of the taller rabbit, the current position of the shorter rabbit, the hopping distance of the taller rabbit, and the hopping distance of the shorter rabbit, respectively.
Output
For each test case, print the single integer: number of seconds the two rabbits will take to be at the same position.
If the two rabbits will never be at the same position simultaneously, print -1.
Example
Input
5
0 10 2 3
0 10 3 3
900000000 1000000000 1 9999999
1 2 1 1
1 3 1 1
Output
2
-1
10
-1
1
Note
The first case is explained in the description.
In the second case, each rabbit will be at position 3 and 7 respectively at the 1-st second. But in the 2-nd second they will be at 6 and 4 respectively, and we can see that they will never be at the same position since the distance between the two rabbits will only increase afterward. | instruction | 0 | 71,789 | 3 | 143,578 |
Tags: math
Correct Solution:
```
for i in range (int(input())):
x,y,a,b=[int(x) for x in input().split()]
k=(y-x)%(a+b)
j=(y-x)//(a+b)
if k==0:
print(j)
else:
print(-1)
``` | output | 1 | 71,789 | 3 | 143,579 |
Provide tags and a correct Python 3 solution for this coding contest problem.
Being tired of participating in too many Codeforces rounds, Gildong decided to take some rest in a park. He sat down on a bench, and soon he found two rabbits hopping around. One of the rabbits was taller than the other.
He noticed that the two rabbits were hopping towards each other. The positions of the two rabbits can be represented as integer coordinates on a horizontal line. The taller rabbit is currently on position x, and the shorter rabbit is currently on position y (x < y). Every second, each rabbit hops to another position. The taller rabbit hops to the positive direction by a, and the shorter rabbit hops to the negative direction by b.
<image>
For example, let's say x=0, y=10, a=2, and b=3. At the 1-st second, each rabbit will be at position 2 and 7. At the 2-nd second, both rabbits will be at position 4.
Gildong is now wondering: Will the two rabbits be at the same position at the same moment? If so, how long will it take? Let's find a moment in time (in seconds) after which the rabbits will be at the same point.
Input
Each test contains one or more test cases. The first line contains the number of test cases t (1 ≤ t ≤ 1000).
Each test case contains exactly one line. The line consists of four integers x, y, a, b (0 ≤ x < y ≤ 10^9, 1 ≤ a,b ≤ 10^9) — the current position of the taller rabbit, the current position of the shorter rabbit, the hopping distance of the taller rabbit, and the hopping distance of the shorter rabbit, respectively.
Output
For each test case, print the single integer: number of seconds the two rabbits will take to be at the same position.
If the two rabbits will never be at the same position simultaneously, print -1.
Example
Input
5
0 10 2 3
0 10 3 3
900000000 1000000000 1 9999999
1 2 1 1
1 3 1 1
Output
2
-1
10
-1
1
Note
The first case is explained in the description.
In the second case, each rabbit will be at position 3 and 7 respectively at the 1-st second. But in the 2-nd second they will be at 6 and 4 respectively, and we can see that they will never be at the same position since the distance between the two rabbits will only increase afterward. | instruction | 0 | 71,790 | 3 | 143,580 |
Tags: math
Correct Solution:
```
#Ashish Sagar
import math
q=int(input())
#q=1
for _ in range(q):
x,y,a,b=map(int,input().split())
if (y-x)%(a+b)==0:
print((y-x)//(a+b))
else:
print(-1)
``` | output | 1 | 71,790 | 3 | 143,581 |
Provide tags and a correct Python 3 solution for this coding contest problem.
Being tired of participating in too many Codeforces rounds, Gildong decided to take some rest in a park. He sat down on a bench, and soon he found two rabbits hopping around. One of the rabbits was taller than the other.
He noticed that the two rabbits were hopping towards each other. The positions of the two rabbits can be represented as integer coordinates on a horizontal line. The taller rabbit is currently on position x, and the shorter rabbit is currently on position y (x < y). Every second, each rabbit hops to another position. The taller rabbit hops to the positive direction by a, and the shorter rabbit hops to the negative direction by b.
<image>
For example, let's say x=0, y=10, a=2, and b=3. At the 1-st second, each rabbit will be at position 2 and 7. At the 2-nd second, both rabbits will be at position 4.
Gildong is now wondering: Will the two rabbits be at the same position at the same moment? If so, how long will it take? Let's find a moment in time (in seconds) after which the rabbits will be at the same point.
Input
Each test contains one or more test cases. The first line contains the number of test cases t (1 ≤ t ≤ 1000).
Each test case contains exactly one line. The line consists of four integers x, y, a, b (0 ≤ x < y ≤ 10^9, 1 ≤ a,b ≤ 10^9) — the current position of the taller rabbit, the current position of the shorter rabbit, the hopping distance of the taller rabbit, and the hopping distance of the shorter rabbit, respectively.
Output
For each test case, print the single integer: number of seconds the two rabbits will take to be at the same position.
If the two rabbits will never be at the same position simultaneously, print -1.
Example
Input
5
0 10 2 3
0 10 3 3
900000000 1000000000 1 9999999
1 2 1 1
1 3 1 1
Output
2
-1
10
-1
1
Note
The first case is explained in the description.
In the second case, each rabbit will be at position 3 and 7 respectively at the 1-st second. But in the 2-nd second they will be at 6 and 4 respectively, and we can see that they will never be at the same position since the distance between the two rabbits will only increase afterward. | instruction | 0 | 71,791 | 3 | 143,582 |
Tags: math
Correct Solution:
```
for i in range(int(input())):
x,y,a,b=list(map(int,input().split()))
if ((y-x)%(a+b))==0:
print((y-x)//(a+b))
else:
print(-1)
``` | output | 1 | 71,791 | 3 | 143,583 |
Provide tags and a correct Python 3 solution for this coding contest problem.
Being tired of participating in too many Codeforces rounds, Gildong decided to take some rest in a park. He sat down on a bench, and soon he found two rabbits hopping around. One of the rabbits was taller than the other.
He noticed that the two rabbits were hopping towards each other. The positions of the two rabbits can be represented as integer coordinates on a horizontal line. The taller rabbit is currently on position x, and the shorter rabbit is currently on position y (x < y). Every second, each rabbit hops to another position. The taller rabbit hops to the positive direction by a, and the shorter rabbit hops to the negative direction by b.
<image>
For example, let's say x=0, y=10, a=2, and b=3. At the 1-st second, each rabbit will be at position 2 and 7. At the 2-nd second, both rabbits will be at position 4.
Gildong is now wondering: Will the two rabbits be at the same position at the same moment? If so, how long will it take? Let's find a moment in time (in seconds) after which the rabbits will be at the same point.
Input
Each test contains one or more test cases. The first line contains the number of test cases t (1 ≤ t ≤ 1000).
Each test case contains exactly one line. The line consists of four integers x, y, a, b (0 ≤ x < y ≤ 10^9, 1 ≤ a,b ≤ 10^9) — the current position of the taller rabbit, the current position of the shorter rabbit, the hopping distance of the taller rabbit, and the hopping distance of the shorter rabbit, respectively.
Output
For each test case, print the single integer: number of seconds the two rabbits will take to be at the same position.
If the two rabbits will never be at the same position simultaneously, print -1.
Example
Input
5
0 10 2 3
0 10 3 3
900000000 1000000000 1 9999999
1 2 1 1
1 3 1 1
Output
2
-1
10
-1
1
Note
The first case is explained in the description.
In the second case, each rabbit will be at position 3 and 7 respectively at the 1-st second. But in the 2-nd second they will be at 6 and 4 respectively, and we can see that they will never be at the same position since the distance between the two rabbits will only increase afterward. | instruction | 0 | 71,792 | 3 | 143,584 |
Tags: math
Correct Solution:
```
t = int(input())
for i in range(t):
x,y,a,b = map(int, input().split())
if (y-x) % (a+b) == 0:
print( int((y-x)/(a+b)) )
else:
print(-1)
``` | output | 1 | 71,792 | 3 | 143,585 |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.