message stringlengths 2 44.5k | message_type stringclasses 2
values | message_id int64 0 1 | conversation_id int64 276 109k | cluster float64 23 23 | __index_level_0__ int64 552 217k |
|---|---|---|---|---|---|
Provide a correct Python 3 solution for this coding contest problem.
There are N points on the 2D plane, i-th of which is located on (x_i, y_i). There can be multiple points that share the same coordinate. What is the maximum possible Manhattan distance between two distinct points?
Here, the Manhattan distance between two points (x_i, y_i) and (x_j, y_j) is defined by |x_i-x_j| + |y_i-y_j|.
Constraints
* 2 \leq N \leq 2 \times 10^5
* 1 \leq x_i,y_i \leq 10^9
* All values in input are integers.
Input
Input is given from Standard Input in the following format:
N
x_1 y_1
x_2 y_2
:
x_N y_N
Output
Print the answer.
Examples
Input
3
1 1
2 4
3 2
Output
4
Input
2
1 1
1 1
Output
0 | instruction | 0 | 44,412 | 23 | 88,824 |
"Correct Solution:
```
n=int(input())
xy=[tuple(map(int, input().split())) for _ in range(n)]
fn=[lambda x:x[0]+x[1],lambda x:x[0]-x[1]]
ans=0
for f in fn:
xy.sort(key = f)
ans=max(ans,abs(f(xy[0])-f(xy[-1])))
print(ans)
``` | output | 1 | 44,412 | 23 | 88,825 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
There are N points on the 2D plane, i-th of which is located on (x_i, y_i). There can be multiple points that share the same coordinate. What is the maximum possible Manhattan distance between two distinct points?
Here, the Manhattan distance between two points (x_i, y_i) and (x_j, y_j) is defined by |x_i-x_j| + |y_i-y_j|.
Constraints
* 2 \leq N \leq 2 \times 10^5
* 1 \leq x_i,y_i \leq 10^9
* All values in input are integers.
Input
Input is given from Standard Input in the following format:
N
x_1 y_1
x_2 y_2
:
x_N y_N
Output
Print the answer.
Examples
Input
3
1 1
2 4
3 2
Output
4
Input
2
1 1
1 1
Output
0
Submitted Solution:
```
N = int(input())
plus = []
minus = []
for _ in range(N):
x, y = map(int, input().split())
plus.append(x + y)
minus.append(x - y)
print(max(max(plus) - min(plus), max(minus) - min(minus)))
``` | instruction | 0 | 44,413 | 23 | 88,826 |
Yes | output | 1 | 44,413 | 23 | 88,827 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
There are N points on the 2D plane, i-th of which is located on (x_i, y_i). There can be multiple points that share the same coordinate. What is the maximum possible Manhattan distance between two distinct points?
Here, the Manhattan distance between two points (x_i, y_i) and (x_j, y_j) is defined by |x_i-x_j| + |y_i-y_j|.
Constraints
* 2 \leq N \leq 2 \times 10^5
* 1 \leq x_i,y_i \leq 10^9
* All values in input are integers.
Input
Input is given from Standard Input in the following format:
N
x_1 y_1
x_2 y_2
:
x_N y_N
Output
Print the answer.
Examples
Input
3
1 1
2 4
3 2
Output
4
Input
2
1 1
1 1
Output
0
Submitted Solution:
```
n = int(input())
xs = []
ys = []
for _ in range(n):
x, y = map(int, input().split())
xs.append(x + y)
ys.append(x - y)
xs.sort()
ys.sort()
ans = max(xs[-1] - xs[0], ys[-1] - ys[0])
print(ans)
``` | instruction | 0 | 44,414 | 23 | 88,828 |
Yes | output | 1 | 44,414 | 23 | 88,829 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
There are N points on the 2D plane, i-th of which is located on (x_i, y_i). There can be multiple points that share the same coordinate. What is the maximum possible Manhattan distance between two distinct points?
Here, the Manhattan distance between two points (x_i, y_i) and (x_j, y_j) is defined by |x_i-x_j| + |y_i-y_j|.
Constraints
* 2 \leq N \leq 2 \times 10^5
* 1 \leq x_i,y_i \leq 10^9
* All values in input are integers.
Input
Input is given from Standard Input in the following format:
N
x_1 y_1
x_2 y_2
:
x_N y_N
Output
Print the answer.
Examples
Input
3
1 1
2 4
3 2
Output
4
Input
2
1 1
1 1
Output
0
Submitted Solution:
```
N = int(input())
X = [list(map(int, input().split())) for _ in range(N)]
z = [x + y for x, y in X]
w = [x - y for x, y in X]
print(max(max(z) - min(z), max(w) - min(w)))
``` | instruction | 0 | 44,415 | 23 | 88,830 |
Yes | output | 1 | 44,415 | 23 | 88,831 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
There are N points on the 2D plane, i-th of which is located on (x_i, y_i). There can be multiple points that share the same coordinate. What is the maximum possible Manhattan distance between two distinct points?
Here, the Manhattan distance between two points (x_i, y_i) and (x_j, y_j) is defined by |x_i-x_j| + |y_i-y_j|.
Constraints
* 2 \leq N \leq 2 \times 10^5
* 1 \leq x_i,y_i \leq 10^9
* All values in input are integers.
Input
Input is given from Standard Input in the following format:
N
x_1 y_1
x_2 y_2
:
x_N y_N
Output
Print the answer.
Examples
Input
3
1 1
2 4
3 2
Output
4
Input
2
1 1
1 1
Output
0
Submitted Solution:
```
n = int(input())
XY = [tuple(map(int, input().split())) for i in range(n)]
A = [x + y for x, y in XY]
B = [x - y for x, y in XY]
print(max(max(A) - min(A), max(B) - min(B)))
``` | instruction | 0 | 44,416 | 23 | 88,832 |
Yes | output | 1 | 44,416 | 23 | 88,833 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
There are N points on the 2D plane, i-th of which is located on (x_i, y_i). There can be multiple points that share the same coordinate. What is the maximum possible Manhattan distance between two distinct points?
Here, the Manhattan distance between two points (x_i, y_i) and (x_j, y_j) is defined by |x_i-x_j| + |y_i-y_j|.
Constraints
* 2 \leq N \leq 2 \times 10^5
* 1 \leq x_i,y_i \leq 10^9
* All values in input are integers.
Input
Input is given from Standard Input in the following format:
N
x_1 y_1
x_2 y_2
:
x_N y_N
Output
Print the answer.
Examples
Input
3
1 1
2 4
3 2
Output
4
Input
2
1 1
1 1
Output
0
Submitted Solution:
```
def main():
n = int(input())
xy = [list(map(int, input().split())) for _ in [0]*n]
z = [max(x+y, x-y) for x, y in xy]
print(max(z)-min(z))
main()
``` | instruction | 0 | 44,417 | 23 | 88,834 |
No | output | 1 | 44,417 | 23 | 88,835 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
There are N points on the 2D plane, i-th of which is located on (x_i, y_i). There can be multiple points that share the same coordinate. What is the maximum possible Manhattan distance between two distinct points?
Here, the Manhattan distance between two points (x_i, y_i) and (x_j, y_j) is defined by |x_i-x_j| + |y_i-y_j|.
Constraints
* 2 \leq N \leq 2 \times 10^5
* 1 \leq x_i,y_i \leq 10^9
* All values in input are integers.
Input
Input is given from Standard Input in the following format:
N
x_1 y_1
x_2 y_2
:
x_N y_N
Output
Print the answer.
Examples
Input
3
1 1
2 4
3 2
Output
4
Input
2
1 1
1 1
Output
0
Submitted Solution:
```
def main():
N = int(input())
points = [None] * N
for i in range(N):
x, y = map(int, input().split())
points[i] = (x, y)
ans = 0
topright = points[0][0] + points[0][1]
bottomright = points[0][0] - points[0][1]
for i in range(N):
tr = points[i][0] + points[i][1]
br = points[i][0] - points[i][1]
ans = max([ans, abs(topright - tr), abs(bottomright - br)])
topright = max(topright, tr)
bottomright = max(bottomright, br)
print(ans)
if __name__ == "__main__":
main()
``` | instruction | 0 | 44,418 | 23 | 88,836 |
No | output | 1 | 44,418 | 23 | 88,837 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
There are N points on the 2D plane, i-th of which is located on (x_i, y_i). There can be multiple points that share the same coordinate. What is the maximum possible Manhattan distance between two distinct points?
Here, the Manhattan distance between two points (x_i, y_i) and (x_j, y_j) is defined by |x_i-x_j| + |y_i-y_j|.
Constraints
* 2 \leq N \leq 2 \times 10^5
* 1 \leq x_i,y_i \leq 10^9
* All values in input are integers.
Input
Input is given from Standard Input in the following format:
N
x_1 y_1
x_2 y_2
:
x_N y_N
Output
Print the answer.
Examples
Input
3
1 1
2 4
3 2
Output
4
Input
2
1 1
1 1
Output
0
Submitted Solution:
```
from collections import defaultdict
N = int(input())
Min = float('inf')
Max = 0
Sum_y = defaultdict(lambda:[])
for i in range(N):
x,y = map(int,input().split())
Sum = x+y
Min = min(Min,Sum)
Max = max(Max,Sum)
Sum_y[Sum].append(y)
ans = Max-Min
for key in Sum_y.keys():
ans = max(ans,2*(max(Sum_y[key])-min(Sum_y[key])))
print(ans)
``` | instruction | 0 | 44,419 | 23 | 88,838 |
No | output | 1 | 44,419 | 23 | 88,839 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
There are N points on the 2D plane, i-th of which is located on (x_i, y_i). There can be multiple points that share the same coordinate. What is the maximum possible Manhattan distance between two distinct points?
Here, the Manhattan distance between two points (x_i, y_i) and (x_j, y_j) is defined by |x_i-x_j| + |y_i-y_j|.
Constraints
* 2 \leq N \leq 2 \times 10^5
* 1 \leq x_i,y_i \leq 10^9
* All values in input are integers.
Input
Input is given from Standard Input in the following format:
N
x_1 y_1
x_2 y_2
:
x_N y_N
Output
Print the answer.
Examples
Input
3
1 1
2 4
3 2
Output
4
Input
2
1 1
1 1
Output
0
Submitted Solution:
```
N = int(input())
xy = [list(map(int, input().split())) for _ in range(N)]
d = [0]*N
for i in range(N):
d[i] = xy[i][0] + xy[i][1]
print(max(d) - min(d))
``` | instruction | 0 | 44,420 | 23 | 88,840 |
No | output | 1 | 44,420 | 23 | 88,841 |
Provide a correct Python 3 solution for this coding contest problem.
We have a long seat of width X centimeters. There are many people who wants to sit here. A person sitting on the seat will always occupy an interval of length Y centimeters.
We would like to seat as many people as possible, but they are all very shy, and there must be a gap of length at least Z centimeters between two people, and between the end of the seat and a person.
At most how many people can sit on the seat?
Constraints
* All input values are integers.
* 1 \leq X, Y, Z \leq 10^5
* Y+2Z \leq X
Input
Input is given from Standard Input in the following format:
X Y Z
Output
Print the answer.
Examples
Input
13 3 1
Output
3
Input
12 3 1
Output
2
Input
100000 1 1
Output
49999
Input
64146 123 456
Output
110
Input
64145 123 456
Output
109 | instruction | 0 | 44,511 | 23 | 89,022 |
"Correct Solution:
```
x,y,z=[int(i) for i in input().split()]
x-=z
print(x//(y+z))
``` | output | 1 | 44,511 | 23 | 89,023 |
Provide a correct Python 3 solution for this coding contest problem.
We have a long seat of width X centimeters. There are many people who wants to sit here. A person sitting on the seat will always occupy an interval of length Y centimeters.
We would like to seat as many people as possible, but they are all very shy, and there must be a gap of length at least Z centimeters between two people, and between the end of the seat and a person.
At most how many people can sit on the seat?
Constraints
* All input values are integers.
* 1 \leq X, Y, Z \leq 10^5
* Y+2Z \leq X
Input
Input is given from Standard Input in the following format:
X Y Z
Output
Print the answer.
Examples
Input
13 3 1
Output
3
Input
12 3 1
Output
2
Input
100000 1 1
Output
49999
Input
64146 123 456
Output
110
Input
64145 123 456
Output
109 | instruction | 0 | 44,512 | 23 | 89,024 |
"Correct Solution:
```
X, Y, Z = map(int, input().split())
print((X-Z)//(Z+Y))
``` | output | 1 | 44,512 | 23 | 89,025 |
Provide a correct Python 3 solution for this coding contest problem.
We have a long seat of width X centimeters. There are many people who wants to sit here. A person sitting on the seat will always occupy an interval of length Y centimeters.
We would like to seat as many people as possible, but they are all very shy, and there must be a gap of length at least Z centimeters between two people, and between the end of the seat and a person.
At most how many people can sit on the seat?
Constraints
* All input values are integers.
* 1 \leq X, Y, Z \leq 10^5
* Y+2Z \leq X
Input
Input is given from Standard Input in the following format:
X Y Z
Output
Print the answer.
Examples
Input
13 3 1
Output
3
Input
12 3 1
Output
2
Input
100000 1 1
Output
49999
Input
64146 123 456
Output
110
Input
64145 123 456
Output
109 | instruction | 0 | 44,513 | 23 | 89,026 |
"Correct Solution:
```
X, Y, Z = map(int, input().split())
r = (X-Z)//(Y+Z)
print(r)
``` | output | 1 | 44,513 | 23 | 89,027 |
Provide a correct Python 3 solution for this coding contest problem.
We have a long seat of width X centimeters. There are many people who wants to sit here. A person sitting on the seat will always occupy an interval of length Y centimeters.
We would like to seat as many people as possible, but they are all very shy, and there must be a gap of length at least Z centimeters between two people, and between the end of the seat and a person.
At most how many people can sit on the seat?
Constraints
* All input values are integers.
* 1 \leq X, Y, Z \leq 10^5
* Y+2Z \leq X
Input
Input is given from Standard Input in the following format:
X Y Z
Output
Print the answer.
Examples
Input
13 3 1
Output
3
Input
12 3 1
Output
2
Input
100000 1 1
Output
49999
Input
64146 123 456
Output
110
Input
64145 123 456
Output
109 | instruction | 0 | 44,514 | 23 | 89,028 |
"Correct Solution:
```
x, y, z = [int(x) for x in input().split()]
print((x - z) // (z + y))
``` | output | 1 | 44,514 | 23 | 89,029 |
Provide a correct Python 3 solution for this coding contest problem.
We have a long seat of width X centimeters. There are many people who wants to sit here. A person sitting on the seat will always occupy an interval of length Y centimeters.
We would like to seat as many people as possible, but they are all very shy, and there must be a gap of length at least Z centimeters between two people, and between the end of the seat and a person.
At most how many people can sit on the seat?
Constraints
* All input values are integers.
* 1 \leq X, Y, Z \leq 10^5
* Y+2Z \leq X
Input
Input is given from Standard Input in the following format:
X Y Z
Output
Print the answer.
Examples
Input
13 3 1
Output
3
Input
12 3 1
Output
2
Input
100000 1 1
Output
49999
Input
64146 123 456
Output
110
Input
64145 123 456
Output
109 | instruction | 0 | 44,515 | 23 | 89,030 |
"Correct Solution:
```
X,Y,Z=map(int,input().split())
a=X-Z
b=Y+Z
print(a//b)
``` | output | 1 | 44,515 | 23 | 89,031 |
Provide a correct Python 3 solution for this coding contest problem.
We have a long seat of width X centimeters. There are many people who wants to sit here. A person sitting on the seat will always occupy an interval of length Y centimeters.
We would like to seat as many people as possible, but they are all very shy, and there must be a gap of length at least Z centimeters between two people, and between the end of the seat and a person.
At most how many people can sit on the seat?
Constraints
* All input values are integers.
* 1 \leq X, Y, Z \leq 10^5
* Y+2Z \leq X
Input
Input is given from Standard Input in the following format:
X Y Z
Output
Print the answer.
Examples
Input
13 3 1
Output
3
Input
12 3 1
Output
2
Input
100000 1 1
Output
49999
Input
64146 123 456
Output
110
Input
64145 123 456
Output
109 | instruction | 0 | 44,516 | 23 | 89,032 |
"Correct Solution:
```
X,Y,Z = map(int, input().split())
answer = (X-Z) // (Y+Z)
print(answer)
``` | output | 1 | 44,516 | 23 | 89,033 |
Provide a correct Python 3 solution for this coding contest problem.
We have a long seat of width X centimeters. There are many people who wants to sit here. A person sitting on the seat will always occupy an interval of length Y centimeters.
We would like to seat as many people as possible, but they are all very shy, and there must be a gap of length at least Z centimeters between two people, and between the end of the seat and a person.
At most how many people can sit on the seat?
Constraints
* All input values are integers.
* 1 \leq X, Y, Z \leq 10^5
* Y+2Z \leq X
Input
Input is given from Standard Input in the following format:
X Y Z
Output
Print the answer.
Examples
Input
13 3 1
Output
3
Input
12 3 1
Output
2
Input
100000 1 1
Output
49999
Input
64146 123 456
Output
110
Input
64145 123 456
Output
109 | instruction | 0 | 44,517 | 23 | 89,034 |
"Correct Solution:
```
x,y,z = map(int,input().split())
print(int((x-z)//(y+z)))
``` | output | 1 | 44,517 | 23 | 89,035 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
We have a long seat of width X centimeters. There are many people who wants to sit here. A person sitting on the seat will always occupy an interval of length Y centimeters.
We would like to seat as many people as possible, but they are all very shy, and there must be a gap of length at least Z centimeters between two people, and between the end of the seat and a person.
At most how many people can sit on the seat?
Constraints
* All input values are integers.
* 1 \leq X, Y, Z \leq 10^5
* Y+2Z \leq X
Input
Input is given from Standard Input in the following format:
X Y Z
Output
Print the answer.
Examples
Input
13 3 1
Output
3
Input
12 3 1
Output
2
Input
100000 1 1
Output
49999
Input
64146 123 456
Output
110
Input
64145 123 456
Output
109
Submitted Solution:
```
X,Y,Z = map(int, input().split())
A = (X-Z)
B = (Y+Z)
print(A//B)
``` | instruction | 0 | 44,519 | 23 | 89,038 |
Yes | output | 1 | 44,519 | 23 | 89,039 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
We have a long seat of width X centimeters. There are many people who wants to sit here. A person sitting on the seat will always occupy an interval of length Y centimeters.
We would like to seat as many people as possible, but they are all very shy, and there must be a gap of length at least Z centimeters between two people, and between the end of the seat and a person.
At most how many people can sit on the seat?
Constraints
* All input values are integers.
* 1 \leq X, Y, Z \leq 10^5
* Y+2Z \leq X
Input
Input is given from Standard Input in the following format:
X Y Z
Output
Print the answer.
Examples
Input
13 3 1
Output
3
Input
12 3 1
Output
2
Input
100000 1 1
Output
49999
Input
64146 123 456
Output
110
Input
64145 123 456
Output
109
Submitted Solution:
```
x,y,z = map(int,input().split())
x -= z
r = x // (y + z)
print(r)
``` | instruction | 0 | 44,521 | 23 | 89,042 |
Yes | output | 1 | 44,521 | 23 | 89,043 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
We have a long seat of width X centimeters. There are many people who wants to sit here. A person sitting on the seat will always occupy an interval of length Y centimeters.
We would like to seat as many people as possible, but they are all very shy, and there must be a gap of length at least Z centimeters between two people, and between the end of the seat and a person.
At most how many people can sit on the seat?
Constraints
* All input values are integers.
* 1 \leq X, Y, Z \leq 10^5
* Y+2Z \leq X
Input
Input is given from Standard Input in the following format:
X Y Z
Output
Print the answer.
Examples
Input
13 3 1
Output
3
Input
12 3 1
Output
2
Input
100000 1 1
Output
49999
Input
64146 123 456
Output
110
Input
64145 123 456
Output
109
Submitted Solution:
```
X, Y, Z = [int(x) for x in input().split()]
print((X - Z)//(Y+Z))
``` | instruction | 0 | 44,522 | 23 | 89,044 |
Yes | output | 1 | 44,522 | 23 | 89,045 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
We have a long seat of width X centimeters. There are many people who wants to sit here. A person sitting on the seat will always occupy an interval of length Y centimeters.
We would like to seat as many people as possible, but they are all very shy, and there must be a gap of length at least Z centimeters between two people, and between the end of the seat and a person.
At most how many people can sit on the seat?
Constraints
* All input values are integers.
* 1 \leq X, Y, Z \leq 10^5
* Y+2Z \leq X
Input
Input is given from Standard Input in the following format:
X Y Z
Output
Print the answer.
Examples
Input
13 3 1
Output
3
Input
12 3 1
Output
2
Input
100000 1 1
Output
49999
Input
64146 123 456
Output
110
Input
64145 123 456
Output
109
Submitted Solution:
```
x, y, z = map(int, input().split())
ans = int((x-1)/(y+z))
print(ans)
``` | instruction | 0 | 44,523 | 23 | 89,046 |
No | output | 1 | 44,523 | 23 | 89,047 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
We have a long seat of width X centimeters. There are many people who wants to sit here. A person sitting on the seat will always occupy an interval of length Y centimeters.
We would like to seat as many people as possible, but they are all very shy, and there must be a gap of length at least Z centimeters between two people, and between the end of the seat and a person.
At most how many people can sit on the seat?
Constraints
* All input values are integers.
* 1 \leq X, Y, Z \leq 10^5
* Y+2Z \leq X
Input
Input is given from Standard Input in the following format:
X Y Z
Output
Print the answer.
Examples
Input
13 3 1
Output
3
Input
12 3 1
Output
2
Input
100000 1 1
Output
49999
Input
64146 123 456
Output
110
Input
64145 123 456
Output
109
Submitted Solution:
```
x, y, z = map(int, input().split())
x -= z
# data = [0] * x
ans = 0
i = 0
space = 0
# 処理系
while i != x:
# 初期値代入
if i == 0:
# y の幅分だけ変更していく
for j in range(y):
# data[i] = 1
i += 1
ans += 1
continue
if not space == z:
space += 1
i += 1
continue
else:
space = 0
current = i + 1
if x - current >= y:
# y の幅分だけ変更していく
for j in range(y):
# data[i] = 1
i += 1
ans += 1
continue
else:
break
# 出力
print( ans )
``` | instruction | 0 | 44,525 | 23 | 89,050 |
No | output | 1 | 44,525 | 23 | 89,051 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
We have a long seat of width X centimeters. There are many people who wants to sit here. A person sitting on the seat will always occupy an interval of length Y centimeters.
We would like to seat as many people as possible, but they are all very shy, and there must be a gap of length at least Z centimeters between two people, and between the end of the seat and a person.
At most how many people can sit on the seat?
Constraints
* All input values are integers.
* 1 \leq X, Y, Z \leq 10^5
* Y+2Z \leq X
Input
Input is given from Standard Input in the following format:
X Y Z
Output
Print the answer.
Examples
Input
13 3 1
Output
3
Input
12 3 1
Output
2
Input
100000 1 1
Output
49999
Input
64146 123 456
Output
110
Input
64145 123 456
Output
109
Submitted Solution:
```
x,y,z=map(int,input().split())
n=0
while(1):
if(n*y+(n+1)*z>x):
break
n+=1
return(n)
``` | instruction | 0 | 44,526 | 23 | 89,052 |
No | output | 1 | 44,526 | 23 | 89,053 |
Provide a correct Python 3 solution for this coding contest problem.
The range search problem consists of a set of attributed records S to determine which records from S intersect with a given range.
For n points on a plane, report a set of points which are within in a given range. Note that you do not need to consider insert and delete operations for the set.
Constraints
* 0 ≤ n ≤ 500,000
* 0 ≤ q ≤ 20,000
* -1,000,000,000 ≤ x, y, sx, tx, sy, ty ≤ 1,000,000,000
* sx ≤ tx
* sy ≤ ty
* For each query, the number of points which are within the range is less than or equal to 100.
Input
n
x0 y0
x1 y1
:
xn-1 yn-1
q
sx0 tx0 sy0 ty0
sx1 tx1 sy1 ty1
:
sxq-1 txq-1 syq-1 tyq-1
The first integer n is the number of points. In the following n lines, the coordinate of the i-th point is given by two integers xi and yi.
The next integer q is the number of queries. In the following q lines, each query is given by four integers, sxi, txi, syi, tyi.
Output
For each query, report IDs of points such that sxi ≤ x ≤ txi and syi ≤ y ≤ tyi. The IDs should be reported in ascending order. Print an ID in a line, and print a blank line at the end of output for the each query.
Example
Input
6
2 1
2 2
4 2
6 2
3 3
5 4
2
2 4 0 4
4 10 2 5
Output
0
1
2
4
2
3
5 | instruction | 0 | 44,610 | 23 | 89,220 |
"Correct Solution:
```
#!/usr/bin/python3
from sys import stdin
import math
from operator import itemgetter
from bisect import bisect_left, bisect_right
readline = stdin.readline
def main():
n = int(readline())
xy = [tuple(map(int, readline().split())) + (i,) for i in range(n)]
# [..., (x_i, y_i, i), ...]
# sort by x
xy.sort()
root = int(math.sqrt(len(xy)))
low = [x for x, y, i in xy[::root]]
high = [x for x, y, i in xy[root - 1::root]] + [float('inf')]
xy = [sorted(xy[i:i + root], key=itemgetter(1)) for i in range(0, len(xy), root)]
xy = [([y for x, y, i in xyi], xyi) for xyi in xy]
for sx, tx, sy, ty in (map(int, readline().split()) for _ in range(int(readline()))):
ret = []
for i in range(bisect_left(high, sx), bisect_right(low, tx)):
k, v = xy[i]
for i in range(bisect_left(k, sy), bisect_right(k, ty)):
if sx <= v[i][0] <=tx:
ret.append(v[i][2])
if ret:
ret.sort()
print('\n'.join(map(str,ret)))
print()
main()
``` | output | 1 | 44,610 | 23 | 89,221 |
Provide a correct Python 3 solution for this coding contest problem.
The range search problem consists of a set of attributed records S to determine which records from S intersect with a given range.
For n points on a plane, report a set of points which are within in a given range. Note that you do not need to consider insert and delete operations for the set.
Constraints
* 0 ≤ n ≤ 500,000
* 0 ≤ q ≤ 20,000
* -1,000,000,000 ≤ x, y, sx, tx, sy, ty ≤ 1,000,000,000
* sx ≤ tx
* sy ≤ ty
* For each query, the number of points which are within the range is less than or equal to 100.
Input
n
x0 y0
x1 y1
:
xn-1 yn-1
q
sx0 tx0 sy0 ty0
sx1 tx1 sy1 ty1
:
sxq-1 txq-1 syq-1 tyq-1
The first integer n is the number of points. In the following n lines, the coordinate of the i-th point is given by two integers xi and yi.
The next integer q is the number of queries. In the following q lines, each query is given by four integers, sxi, txi, syi, tyi.
Output
For each query, report IDs of points such that sxi ≤ x ≤ txi and syi ≤ y ≤ tyi. The IDs should be reported in ascending order. Print an ID in a line, and print a blank line at the end of output for the each query.
Example
Input
6
2 1
2 2
4 2
6 2
3 3
5 4
2
2 4 0 4
4 10 2 5
Output
0
1
2
4
2
3
5 | instruction | 0 | 44,611 | 23 | 89,222 |
"Correct Solution:
```
from sys import stdin
import math
from operator import itemgetter
from bisect import bisect_left, bisect_right
def main():
xy = [tuple(map(int, input().split()))+(i, ) for i in range(int(input()))]
xy.sort()
root = int(math.sqrt(len(xy)))
low = [x for x,y,i in xy[::root]]
high = [x for x, y, i in xy[root-1::root]] + [float('inf')]
xy = [sorted(xy[i:i+root],key = itemgetter(1)) for i in range(0,len(xy),root)]
xy = [([y for x,y,i in xyi], xyi) for xyi in xy]
q = int(input())
for _ in range(q):
sx, tx, sy, ty = map(int, input().split())
ans = []
for i in range(bisect_left(high,sx),bisect_right(low,tx)):
k, v = xy[i]
for i in range(bisect_left(k, sy),bisect_right(k,ty)):
if sx <= v[i][0] <=tx:
ans.append(v[i][2])
if ans:
ans.sort()
print('\n'.join(map(str,ans)))
print()
main()
``` | output | 1 | 44,611 | 23 | 89,223 |
Provide a correct Python 3 solution for this coding contest problem.
The range search problem consists of a set of attributed records S to determine which records from S intersect with a given range.
For n points on a plane, report a set of points which are within in a given range. Note that you do not need to consider insert and delete operations for the set.
Constraints
* 0 ≤ n ≤ 500,000
* 0 ≤ q ≤ 20,000
* -1,000,000,000 ≤ x, y, sx, tx, sy, ty ≤ 1,000,000,000
* sx ≤ tx
* sy ≤ ty
* For each query, the number of points which are within the range is less than or equal to 100.
Input
n
x0 y0
x1 y1
:
xn-1 yn-1
q
sx0 tx0 sy0 ty0
sx1 tx1 sy1 ty1
:
sxq-1 txq-1 syq-1 tyq-1
The first integer n is the number of points. In the following n lines, the coordinate of the i-th point is given by two integers xi and yi.
The next integer q is the number of queries. In the following q lines, each query is given by four integers, sxi, txi, syi, tyi.
Output
For each query, report IDs of points such that sxi ≤ x ≤ txi and syi ≤ y ≤ tyi. The IDs should be reported in ascending order. Print an ID in a line, and print a blank line at the end of output for the each query.
Example
Input
6
2 1
2 2
4 2
6 2
3 3
5 4
2
2 4 0 4
4 10 2 5
Output
0
1
2
4
2
3
5 | instruction | 0 | 44,612 | 23 | 89,224 |
"Correct Solution:
```
from sys import stdin
import math
from operator import itemgetter
from bisect import bisect_left, bisect_right
readline = stdin.readline
def main():
n = int(readline())
xy = [tuple(map(int, readline().split())) + (i,) for i in range(n)]
xy.sort()
root = int(math.sqrt(len(xy)))
low = [x for x, y, i in xy[::root]]
high = [x for x, y, i in xy[root - 1::root]] + [float('inf')]
xy = [sorted(xy[i:i + root], key=itemgetter(1)) for i in range(0, len(xy), root)]
xy = [([y for x, y, i in xyi], xyi) for xyi in xy]
A = []
for sx, tx, sy, ty in (map(int, readline().split()) for _ in range(int(readline()))):
ret = []
for i in range(bisect_left(high, sx), bisect_right(low, tx)):
k, v = xy[i]
for i in range(bisect_left(k, sy), bisect_right(k, ty)):
if sx <= v[i][0] <=tx:
ret.append(v[i][2])
if ret:
ret.sort()
A.extend(ret)
A.append('')
print('\n'.join(map(str, A)))
main()
``` | output | 1 | 44,612 | 23 | 89,225 |
Provide a correct Python 3 solution for this coding contest problem.
The range search problem consists of a set of attributed records S to determine which records from S intersect with a given range.
For n points on a plane, report a set of points which are within in a given range. Note that you do not need to consider insert and delete operations for the set.
Constraints
* 0 ≤ n ≤ 500,000
* 0 ≤ q ≤ 20,000
* -1,000,000,000 ≤ x, y, sx, tx, sy, ty ≤ 1,000,000,000
* sx ≤ tx
* sy ≤ ty
* For each query, the number of points which are within the range is less than or equal to 100.
Input
n
x0 y0
x1 y1
:
xn-1 yn-1
q
sx0 tx0 sy0 ty0
sx1 tx1 sy1 ty1
:
sxq-1 txq-1 syq-1 tyq-1
The first integer n is the number of points. In the following n lines, the coordinate of the i-th point is given by two integers xi and yi.
The next integer q is the number of queries. In the following q lines, each query is given by four integers, sxi, txi, syi, tyi.
Output
For each query, report IDs of points such that sxi ≤ x ≤ txi and syi ≤ y ≤ tyi. The IDs should be reported in ascending order. Print an ID in a line, and print a blank line at the end of output for the each query.
Example
Input
6
2 1
2 2
4 2
6 2
3 3
5 4
2
2 4 0 4
4 10 2 5
Output
0
1
2
4
2
3
5 | instruction | 0 | 44,613 | 23 | 89,226 |
"Correct Solution:
```
from sys import stdin
import math
from operator import itemgetter
from bisect import bisect_left, bisect_right
readline = stdin.readline
def main():
xy = [tuple(map(int, readline().split())) + (i, ) for i in range(int(readline()))]
xy.sort()
root = int(math.sqrt(len(xy)))
low = [x for x, y, i in xy[::root]]
high = [x for x, y, i in xy[root - 1::root]] + [float('inf')]
xy = [sorted(xy[i:i+root], key=itemgetter(1)) for i in range(0, len(xy),root)]
xy = [([y for x, y, i in xyi], xyi) for xyi in xy]
for sx, tx, sy, ty, in (map(int, readline().split()) for _ in range(int(readline()))):
ret =[]
for i in range(bisect_left(high, sx), bisect_right(low, tx)):
k,v = xy[i]
for i in range(bisect_left(k, sy), bisect_right(k, ty)):
if sx <= v[i][0]<=tx:
ret.append(v[i][2])
if ret:
ret.sort()
print('\n'.join(map(str, ret)))
print()
main()
``` | output | 1 | 44,613 | 23 | 89,227 |
Provide a correct Python 3 solution for this coding contest problem.
The range search problem consists of a set of attributed records S to determine which records from S intersect with a given range.
For n points on a plane, report a set of points which are within in a given range. Note that you do not need to consider insert and delete operations for the set.
Constraints
* 0 ≤ n ≤ 500,000
* 0 ≤ q ≤ 20,000
* -1,000,000,000 ≤ x, y, sx, tx, sy, ty ≤ 1,000,000,000
* sx ≤ tx
* sy ≤ ty
* For each query, the number of points which are within the range is less than or equal to 100.
Input
n
x0 y0
x1 y1
:
xn-1 yn-1
q
sx0 tx0 sy0 ty0
sx1 tx1 sy1 ty1
:
sxq-1 txq-1 syq-1 tyq-1
The first integer n is the number of points. In the following n lines, the coordinate of the i-th point is given by two integers xi and yi.
The next integer q is the number of queries. In the following q lines, each query is given by four integers, sxi, txi, syi, tyi.
Output
For each query, report IDs of points such that sxi ≤ x ≤ txi and syi ≤ y ≤ tyi. The IDs should be reported in ascending order. Print an ID in a line, and print a blank line at the end of output for the each query.
Example
Input
6
2 1
2 2
4 2
6 2
3 3
5 4
2
2 4 0 4
4 10 2 5
Output
0
1
2
4
2
3
5 | instruction | 0 | 44,614 | 23 | 89,228 |
"Correct Solution:
```
import math
from operator import itemgetter
from bisect import bisect_left, bisect_right
def resolve():
N = int(input())
XY = [tuple(map(int, input().split())) + (i,) for i in range(N)]
XY.sort()
root = int(math.sqrt(N))
low = [x for x, y, id in XY[::root]]
high = [x for x, y, i in XY[root - 1::root]] + [float('inf')]
XY = [sorted(XY[i:i + root], key=itemgetter(1)) for i in range(0, N, root)]
XY = [([y for x, y, i in xyi], xyi) for xyi in XY]
Q = int(input())
for _ in range(Q):
sx, tx, sy, ty = map(int, input().split())
ret = []
for i in range(bisect_left(high, sx), bisect_right(low, tx)):
k, v = XY[i]
for i in range(bisect_left(k, sy), bisect_right(k, ty)):
if sx <= v[i][0] <= tx:
ret.append(v[i][2])
if ret:
ret.sort()
print('\n'.join(map(str, ret)))
print()
if __name__ == '__main__':
resolve()
``` | output | 1 | 44,614 | 23 | 89,229 |
Provide a correct Python 3 solution for this coding contest problem.
The range search problem consists of a set of attributed records S to determine which records from S intersect with a given range.
For n points on a plane, report a set of points which are within in a given range. Note that you do not need to consider insert and delete operations for the set.
Constraints
* 0 ≤ n ≤ 500,000
* 0 ≤ q ≤ 20,000
* -1,000,000,000 ≤ x, y, sx, tx, sy, ty ≤ 1,000,000,000
* sx ≤ tx
* sy ≤ ty
* For each query, the number of points which are within the range is less than or equal to 100.
Input
n
x0 y0
x1 y1
:
xn-1 yn-1
q
sx0 tx0 sy0 ty0
sx1 tx1 sy1 ty1
:
sxq-1 txq-1 syq-1 tyq-1
The first integer n is the number of points. In the following n lines, the coordinate of the i-th point is given by two integers xi and yi.
The next integer q is the number of queries. In the following q lines, each query is given by four integers, sxi, txi, syi, tyi.
Output
For each query, report IDs of points such that sxi ≤ x ≤ txi and syi ≤ y ≤ tyi. The IDs should be reported in ascending order. Print an ID in a line, and print a blank line at the end of output for the each query.
Example
Input
6
2 1
2 2
4 2
6 2
3 3
5 4
2
2 4 0 4
4 10 2 5
Output
0
1
2
4
2
3
5 | instruction | 0 | 44,615 | 23 | 89,230 |
"Correct Solution:
```
from sys import stdin
import math
from operator import itemgetter
from bisect import bisect_left, bisect_right
readline = stdin.readline
def main():
xy = [tuple(map(int, readline().split())) + (i,) for i in range(int(readline()))]
xy.sort()
root = int(math.sqrt(len(xy)))
low = [x for x, y, i in xy[::root]]
high = [x for x, y, i in xy[root - 1::root]] + [float('inf')]
xy = [sorted(xy[i:i+root], key=itemgetter(1)) for i in range(0,len(xy),root)]
xy = [([y for x, y, i in xyi], xyi) for xyi in xy]
for sx, tx, sy, ty in (map(int, readline().split()) for _ in range(int(readline()))):
ret = []
for i in range(bisect_left(high, sx), bisect_right(low, tx)):
k, v = xy[i]
for i in range(bisect_left(k, sy), bisect_right(k, ty)):
if sx <= v[i][0] <=tx:
ret.append(v[i][2])
if ret:
ret.sort()
print('\n'.join(map(str,ret)))
print()
main()
``` | output | 1 | 44,615 | 23 | 89,231 |
Provide a correct Python 3 solution for this coding contest problem.
The range search problem consists of a set of attributed records S to determine which records from S intersect with a given range.
For n points on a plane, report a set of points which are within in a given range. Note that you do not need to consider insert and delete operations for the set.
Constraints
* 0 ≤ n ≤ 500,000
* 0 ≤ q ≤ 20,000
* -1,000,000,000 ≤ x, y, sx, tx, sy, ty ≤ 1,000,000,000
* sx ≤ tx
* sy ≤ ty
* For each query, the number of points which are within the range is less than or equal to 100.
Input
n
x0 y0
x1 y1
:
xn-1 yn-1
q
sx0 tx0 sy0 ty0
sx1 tx1 sy1 ty1
:
sxq-1 txq-1 syq-1 tyq-1
The first integer n is the number of points. In the following n lines, the coordinate of the i-th point is given by two integers xi and yi.
The next integer q is the number of queries. In the following q lines, each query is given by four integers, sxi, txi, syi, tyi.
Output
For each query, report IDs of points such that sxi ≤ x ≤ txi and syi ≤ y ≤ tyi. The IDs should be reported in ascending order. Print an ID in a line, and print a blank line at the end of output for the each query.
Example
Input
6
2 1
2 2
4 2
6 2
3 3
5 4
2
2 4 0 4
4 10 2 5
Output
0
1
2
4
2
3
5 | instruction | 0 | 44,616 | 23 | 89,232 |
"Correct Solution:
```
from sys import stdin
import math
from operator import itemgetter, attrgetter
from bisect import bisect_left, bisect_right
n = int(stdin.readline())
lx = []
ly = []
li = []
for i in range(n):
x, y = map(int, stdin.readline().split())
lx.append(x)
ly.append(y)
li.append(i)
x_width = max(lx) - min(lx)
y_width = max(ly) - min(ly)
if x_width > y_width:
P = list(zip(lx, ly, li))
else:
P = list(zip(ly, lx, li))
P.sort()
interval = int(math.sqrt(n))
low = [v1 for v1, v2, i in P[::interval]]
high = [v1 for v1, v2, i in P[interval - 1::interval]] + [float('inf')]
S = []
v2_sec_list = []
for i in range(0, n, interval):
si = P[i:i + interval]
si.sort(key=itemgetter(1))
v2_s = [p[1] for p in si]
v2_sec_list.append(v2_s)
S.append(si)
A = []
q = int(stdin.readline())
for _ in range(q):
sx, tx, sy, ty = map(int, stdin.readline().split())
if x_width <= y_width:
sx, sy, tx, ty = sy, sx, ty, tx
a = []
for i in range(bisect_left(high, sx), bisect_right(low, tx)):
v = S[i]
k = v2_sec_list[i]
for j in range(bisect_left(k, sy), bisect_right(k, ty)):
if sx <= v[j][0] <= tx:
a.append(v[j][2])
if a:
a.sort()
A.extend(a)
A.append('')
print('\n'.join(map(str, A)))
``` | output | 1 | 44,616 | 23 | 89,233 |
Provide a correct Python 3 solution for this coding contest problem.
The range search problem consists of a set of attributed records S to determine which records from S intersect with a given range.
For n points on a plane, report a set of points which are within in a given range. Note that you do not need to consider insert and delete operations for the set.
Constraints
* 0 ≤ n ≤ 500,000
* 0 ≤ q ≤ 20,000
* -1,000,000,000 ≤ x, y, sx, tx, sy, ty ≤ 1,000,000,000
* sx ≤ tx
* sy ≤ ty
* For each query, the number of points which are within the range is less than or equal to 100.
Input
n
x0 y0
x1 y1
:
xn-1 yn-1
q
sx0 tx0 sy0 ty0
sx1 tx1 sy1 ty1
:
sxq-1 txq-1 syq-1 tyq-1
The first integer n is the number of points. In the following n lines, the coordinate of the i-th point is given by two integers xi and yi.
The next integer q is the number of queries. In the following q lines, each query is given by four integers, sxi, txi, syi, tyi.
Output
For each query, report IDs of points such that sxi ≤ x ≤ txi and syi ≤ y ≤ tyi. The IDs should be reported in ascending order. Print an ID in a line, and print a blank line at the end of output for the each query.
Example
Input
6
2 1
2 2
4 2
6 2
3 3
5 4
2
2 4 0 4
4 10 2 5
Output
0
1
2
4
2
3
5 | instruction | 0 | 44,617 | 23 | 89,234 |
"Correct Solution:
```
#!/usr/bin/env pypy3
# DSL_2_C: Range Search(kD Tree)
from bisect import bisect_left, bisect_right
from collections import deque
from functools import lru_cache
from itertools import islice
from math import floor, log2, sqrt
from operator import itemgetter
from sys import stdin, stdout
def sort3(i, j, k):
if i > j:
if j > k:
return (2, 1, 0)
elif i > k:
return (1, 2, 0)
else:
return (1, 0, 2)
else:
if i > k:
return (2, 0, 1)
elif j > k:
return (0, 2, 1)
else:
return (0, 1, 2)
def partition(ps, lo, hi, dim):
mid = (lo + hi) // 2
ns = (lo, mid, hi)
n0, n1, n2 = sort3(ps[lo][dim], ps[mid][dim], ps[hi][dim])
ps[lo], ps[mid], ps[hi] = ps[ns[n1]], ps[ns[n0]], ps[ns[n2]]
v = ps[lo][dim]
i, j = lo, hi
while True:
i, j = i+1, j-1
while ps[i][dim] < v:
i += 1
while ps[j][dim] > v:
j -= 1
if i >= j:
break
ps[i], ps[j] = ps[j], ps[i]
ps[j], ps[lo] = ps[lo], ps[j]
return j
def sort(ps, lo, hi, dim):
for i, p in enumerate(sorted(ps[lo:hi+1], key=itemgetter(dim))):
ps[lo+i] = p
def halve(ps, s, t, dim):
mid = (s+t) // 2
while t - s > 100:
i = partition(ps, s, t, dim)
if i > mid:
t = i - 1
elif i < mid:
s = i + 1
else:
return mid
sort(ps, s, t, dim)
return mid
def build(ps, n, sz, _dim):
q = deque([(0, n-1, 0)])
while q:
s, t, lv = q.popleft()
dim, _ = _dim(lv)
if t - s < sz:
sort(ps, s, t, dim)
continue
mid = halve(ps, s, t, dim)
if mid-1 > s:
q.append((s, mid-1, lv+1))
if t > mid+1:
q.append((mid+1, t, lv+1))
def search(ps, vs, n, sz, _dim, s, t):
q = deque([(0, n-1, 0)])
ret = []
while q:
i, j, lv = q.popleft()
dim, rdim = _dim(lv)
sd, td, sr, tr = s[dim], t[dim], s[rdim], t[rdim]
if j - i < sz:
left = bisect_left(vs[dim], sd, i, j+1)
right = bisect_right(vs[dim], td, i, j+1)
ret.extend([p[2] for p in ps[left:right] if sr <= p[rdim] <= tr])
continue
mid = (i+j) // 2
if td < ps[mid][dim]:
q.append((i, mid-1, lv+1))
elif sd > ps[mid][dim]:
q.append((mid+1, j, lv+1))
else:
if sr <= ps[mid][rdim] <= tr:
ret.append(ps[mid][2])
q.append((i, mid-1, lv+1))
q.append((mid+1, j, lv+1))
ret.sort()
return ret
def dimension(ps, n):
@lru_cache(maxsize=n)
def _dimension(lv):
return pat[lv % len(pat)]
cx = len(set([p[0] for p in ps]))
cy = len(set([p[1] for p in ps]))
if cx < cy:
m, s = 1, 0
ratio = min(cy // cx, floor(log2(n)))
else:
m, s = 0, 1
ratio = min(cx // cy, floor(log2(n)))
pat = []
for _ in range(ratio):
pat.append((m, s))
pat.append((s, m))
return _dimension
def run():
n = int(input())
sz = floor(sqrt(n))
ps = []
for i, line in enumerate(islice(stdin, n)):
x, y = map(int, line.split())
ps.append((x, y, i))
dim = dimension(ps, n)
build(ps, n, sz, dim)
input() # q
vs = ([p[0] for p in ps], [p[1] for p in ps])
for line in stdin:
sx, tx, sy, ty = [int(v) for v in line.split()]
s = "".join([f"{id_}\n" for id_ in
search(ps, vs, n, sz, dim, (sx, sy), (tx, ty))])
stdout.write(s + "\n")
if __name__ == '__main__':
run()
``` | output | 1 | 44,617 | 23 | 89,235 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
The range search problem consists of a set of attributed records S to determine which records from S intersect with a given range.
For n points on a plane, report a set of points which are within in a given range. Note that you do not need to consider insert and delete operations for the set.
Constraints
* 0 ≤ n ≤ 500,000
* 0 ≤ q ≤ 20,000
* -1,000,000,000 ≤ x, y, sx, tx, sy, ty ≤ 1,000,000,000
* sx ≤ tx
* sy ≤ ty
* For each query, the number of points which are within the range is less than or equal to 100.
Input
n
x0 y0
x1 y1
:
xn-1 yn-1
q
sx0 tx0 sy0 ty0
sx1 tx1 sy1 ty1
:
sxq-1 txq-1 syq-1 tyq-1
The first integer n is the number of points. In the following n lines, the coordinate of the i-th point is given by two integers xi and yi.
The next integer q is the number of queries. In the following q lines, each query is given by four integers, sxi, txi, syi, tyi.
Output
For each query, report IDs of points such that sxi ≤ x ≤ txi and syi ≤ y ≤ tyi. The IDs should be reported in ascending order. Print an ID in a line, and print a blank line at the end of output for the each query.
Example
Input
6
2 1
2 2
4 2
6 2
3 3
5 4
2
2 4 0 4
4 10 2 5
Output
0
1
2
4
2
3
5
Submitted Solution:
```
import sys, math
from operator import itemgetter
from bisect import bisect_left, bisect_right
f_i = sys.stdin
def main():
n = int(f_i.readline())
lx = []
ly = []
li = []
for i in range(n):
x, y = map(int, f_i.readline().split())
lx.append(x)
ly.append(y)
li.append(i)
x_width = max(lx) - min(lx)
y_width = max(ly) - min(ly)
if x_width > y_width:
P = list(zip(lx, ly, li))
else:
P = list(zip(ly, lx, li))
P.sort()
interval = int(math.sqrt(n))
low = [v1 for v1, v2, i in P[::interval]]
high = [v1 for v1, v2, i in P[interval - 1::interval]] + [float('inf')]
S = []
v2_sec_list = []
for i in range(0, n, interval):
si = P[i:i + interval]
si.sort(key=itemgetter(1))
v2_s = [p[1] for p in si]
v2_sec_list.append(v2_s)
S.append(si)
A = []
q = f_i.readline()
for l in f_i:
sx, tx, sy, ty = map(int, l.split())
a = []
if x_width > y_width:
for i in range(bisect_left(high, sx), bisect_right(low, tx)):
v = S[i]
k = v2_sec_list[i]
for j in range(bisect_left(k, sy), bisect_right(k, ty)):
if sx <= v[j][0] <= tx:
a.append(v[j][2])
else:
for i in range(bisect_left(high, sy), bisect_right(low, ty)):
v = S[i]
k = v2_sec_list[i]
for j in range(bisect_left(k, sx), bisect_right(k, tx)):
if sy <= v[j][0] <= ty:
a.append(v[j][2])
if a:
a.sort()
A.extend(a)
A.append('')
print('\n'.join(map(str, A)))
main()
``` | instruction | 0 | 44,618 | 23 | 89,236 |
Yes | output | 1 | 44,618 | 23 | 89,237 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
The range search problem consists of a set of attributed records S to determine which records from S intersect with a given range.
For n points on a plane, report a set of points which are within in a given range. Note that you do not need to consider insert and delete operations for the set.
Constraints
* 0 ≤ n ≤ 500,000
* 0 ≤ q ≤ 20,000
* -1,000,000,000 ≤ x, y, sx, tx, sy, ty ≤ 1,000,000,000
* sx ≤ tx
* sy ≤ ty
* For each query, the number of points which are within the range is less than or equal to 100.
Input
n
x0 y0
x1 y1
:
xn-1 yn-1
q
sx0 tx0 sy0 ty0
sx1 tx1 sy1 ty1
:
sxq-1 txq-1 syq-1 tyq-1
The first integer n is the number of points. In the following n lines, the coordinate of the i-th point is given by two integers xi and yi.
The next integer q is the number of queries. In the following q lines, each query is given by four integers, sxi, txi, syi, tyi.
Output
For each query, report IDs of points such that sxi ≤ x ≤ txi and syi ≤ y ≤ tyi. The IDs should be reported in ascending order. Print an ID in a line, and print a blank line at the end of output for the each query.
Example
Input
6
2 1
2 2
4 2
6 2
3 3
5 4
2
2 4 0 4
4 10 2 5
Output
0
1
2
4
2
3
5
Submitted Solution:
```
#!python3
import sys
from bisect import bisect
iim = lambda: map(int, input().rstrip().split())
def resolve():
N = int(input())
inf = 10**9+1
A = []
for i in range(N):
x, y = map(int, sys.stdin.readline().split())
A.append((x, y, i))
A.sort()
lo, hi = 100, N//2+1
while lo < hi:
md = (lo + hi) // 2
if md**2 <= N:
lo = md + 1
else:
hi = md
step = lo
#S = [(-inf, [])]
S = []
for i in range(0, N, step):
ss = list(map(lambda x: (x[1], x), A[i:i+step]))
x1 = ss[0][1][0]
ss.sort()
S.append((x1, ss))
Q = int(input())
ans = []
#print(step)
#print(A)
#print(S)
for x1, x2, y1, y2 in (map(int, line.split()) for line in sys.stdin):
ix1, ix2 = bisect(A, (x1, y1-1)), bisect(A, (x2, y2+1))
r1, r2 = ix1 // step, ix2 // step
S1 = [S[i][1] for i in range(r1 + 1, r2)]
v1, v2 = (y1,), (y2+1,)
ans1 = []
if S1:
ss = S[r1][1]
a1 = bisect(ss, v1)
a2 = bisect(ss, v2, a1)
for i in range(a1, a2):
val = ss[i][1]
if x1 <= val[0]:
ans1.append(val[2])
ss = S[r2][1]
a1 = bisect(ss, v1)
a2 = bisect(ss, v2, a1)
for i in range(a1, a2):
val = ss[i][1]
if val[0] <= x2:
ans1.append(val[2])
else:
for i in range(ix1, ix2):
val = A[i]
if y1 <= val[1] <= y2:
ans1.append(val[2])
ans1.sort()
ans.append(ans1)
continue
for ss in S1:
a1 = bisect(ss, v1)
a2 = bisect(ss, v2, a1)
for j in range(a1, a2):
ans1.append(ss[j][1][2])
#print(S1)
ans1.sort()
ans.append(ans1)
#print("=", ans[-1])
ss, br = "", "\n"
for aa in ans:
if len(aa):
ss += br.join(map(str, aa)) + br
ss += br
print(ss, end="")
if __name__ == "__main__":
resolve()
``` | instruction | 0 | 44,619 | 23 | 89,238 |
Yes | output | 1 | 44,619 | 23 | 89,239 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
The range search problem consists of a set of attributed records S to determine which records from S intersect with a given range.
For n points on a plane, report a set of points which are within in a given range. Note that you do not need to consider insert and delete operations for the set.
Constraints
* 0 ≤ n ≤ 500,000
* 0 ≤ q ≤ 20,000
* -1,000,000,000 ≤ x, y, sx, tx, sy, ty ≤ 1,000,000,000
* sx ≤ tx
* sy ≤ ty
* For each query, the number of points which are within the range is less than or equal to 100.
Input
n
x0 y0
x1 y1
:
xn-1 yn-1
q
sx0 tx0 sy0 ty0
sx1 tx1 sy1 ty1
:
sxq-1 txq-1 syq-1 tyq-1
The first integer n is the number of points. In the following n lines, the coordinate of the i-th point is given by two integers xi and yi.
The next integer q is the number of queries. In the following q lines, each query is given by four integers, sxi, txi, syi, tyi.
Output
For each query, report IDs of points such that sxi ≤ x ≤ txi and syi ≤ y ≤ tyi. The IDs should be reported in ascending order. Print an ID in a line, and print a blank line at the end of output for the each query.
Example
Input
6
2 1
2 2
4 2
6 2
3 3
5 4
2
2 4 0 4
4 10 2 5
Output
0
1
2
4
2
3
5
Submitted Solution:
```
# -*- coding: utf-8 -*-
import math
from operator import itemgetter
from bisect import bisect_left, bisect_right
if __name__ == '__main__':
P = [tuple(map(int, input().split())) + (i,)
for i in range(int(input()))] # (x,y,i)
P.sort()
root = int(math.sqrt(len(P)))
low = [x for x, y, i in P[::root]]
high = [x for x, y, i in P[root - 1::root]] + [float('inf')]
# disjoint subsets (ordered by y) of P
P = [sorted(P[i:i + root], key=itemgetter(1))
for i in range(0, len(P), root)]
P = [([y for x, y, i in Pi], Pi)
for Pi in P] # ([y in subsets], [subsets])
q = int(input())
Q = [list(map(int, input().split(" "))) for _ in range(q)]
for sx, tx, sy, ty in Q:
ret = []
for i in range(bisect_left(high, sx), bisect_right(low, tx)):
k, v = P[i]
for i in range(bisect_left(k, sy), bisect_right(k, ty)):
if sx <= v[i][0] <= tx:
ret.append(v[i][2])
if ret:
ret.sort()
print('\n'.join(map(str, ret)))
print()
``` | instruction | 0 | 44,620 | 23 | 89,240 |
Yes | output | 1 | 44,620 | 23 | 89,241 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
The range search problem consists of a set of attributed records S to determine which records from S intersect with a given range.
For n points on a plane, report a set of points which are within in a given range. Note that you do not need to consider insert and delete operations for the set.
Constraints
* 0 ≤ n ≤ 500,000
* 0 ≤ q ≤ 20,000
* -1,000,000,000 ≤ x, y, sx, tx, sy, ty ≤ 1,000,000,000
* sx ≤ tx
* sy ≤ ty
* For each query, the number of points which are within the range is less than or equal to 100.
Input
n
x0 y0
x1 y1
:
xn-1 yn-1
q
sx0 tx0 sy0 ty0
sx1 tx1 sy1 ty1
:
sxq-1 txq-1 syq-1 tyq-1
The first integer n is the number of points. In the following n lines, the coordinate of the i-th point is given by two integers xi and yi.
The next integer q is the number of queries. In the following q lines, each query is given by four integers, sxi, txi, syi, tyi.
Output
For each query, report IDs of points such that sxi ≤ x ≤ txi and syi ≤ y ≤ tyi. The IDs should be reported in ascending order. Print an ID in a line, and print a blank line at the end of output for the each query.
Example
Input
6
2 1
2 2
4 2
6 2
3 3
5 4
2
2 4 0 4
4 10 2 5
Output
0
1
2
4
2
3
5
Submitted Solution:
```
import math
import sys
from bisect import bisect_left, bisect_right
from typing import List, Optional, Tuple
class KDTree(object):
def __init__(self, n: int) -> None:
self.n = n
self.root = int(math.sqrt(n))
self.coordinates = [(0, 0, 0)] * n
self.low: List[int] = []
self.high: List[int] = []
self.coordinates_: List[Tuple[List[int], List[Tuple[int, int, int]]]] = []
def add(self, x: int, y: int, idx: int) -> None:
self.coordinates[idx] = (x, y, idx)
def prepare(self) -> None:
self.coordinates.sort()
self.low = [x for x, _, _ in self.coordinates[::self.root]]
self.high = [x for x, _, _
in self.coordinates[self.root - 1::self.root]] + [sys.maxsize]
tmp = [sorted(self.coordinates[i: i + self.root], key=lambda x: x[1])
for i in range(0, self.n, self.root)]
self.coordinates_ = [([y for _, y, _ in xyi], xyi) for xyi in tmp]
def find_points(self, sx: int, tx: int, sy: int, ty: int) -> Optional[List[int]]:
ans = []
for i in range(bisect_left(self.high, sx), bisect_right(self.low, tx)):
k, v = self.coordinates_[i]
for j in range(bisect_left(k, sy), bisect_right(k, ty)):
if sx <= v[j][0] <= tx:
ans.append(v[j][2])
return ans
if __name__ == "__main__":
n = int(input())
kdtree = KDTree(n)
for idx in range(n):
x, y = map(lambda x: int(x), input().split())
kdtree.add(x, y, idx)
kdtree.prepare()
q = int(input())
for _ in range(q):
sx, tx, sy, ty = map(lambda x: int(x), input().split())
ans = kdtree.find_points(sx, tx, sy, ty)
if ans:
ans.sort()
print("\n".join(map(str, ans)))
print()
``` | instruction | 0 | 44,621 | 23 | 89,242 |
Yes | output | 1 | 44,621 | 23 | 89,243 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
The range search problem consists of a set of attributed records S to determine which records from S intersect with a given range.
For n points on a plane, report a set of points which are within in a given range. Note that you do not need to consider insert and delete operations for the set.
Constraints
* 0 ≤ n ≤ 500,000
* 0 ≤ q ≤ 20,000
* -1,000,000,000 ≤ x, y, sx, tx, sy, ty ≤ 1,000,000,000
* sx ≤ tx
* sy ≤ ty
* For each query, the number of points which are within the range is less than or equal to 100.
Input
n
x0 y0
x1 y1
:
xn-1 yn-1
q
sx0 tx0 sy0 ty0
sx1 tx1 sy1 ty1
:
sxq-1 txq-1 syq-1 tyq-1
The first integer n is the number of points. In the following n lines, the coordinate of the i-th point is given by two integers xi and yi.
The next integer q is the number of queries. In the following q lines, each query is given by four integers, sxi, txi, syi, tyi.
Output
For each query, report IDs of points such that sxi ≤ x ≤ txi and syi ≤ y ≤ tyi. The IDs should be reported in ascending order. Print an ID in a line, and print a blank line at the end of output for the each query.
Example
Input
6
2 1
2 2
4 2
6 2
3 3
5 4
2
2 4 0 4
4 10 2 5
Output
0
1
2
4
2
3
5
Submitted Solution:
```
class Bound:
def __init__(self, sx, tx, sy, ty):
self.sx = sx
self.tx = tx
self.sy = sy
self.ty = ty
def contains(self, point):
return self.sx <= point[1] <= self.tx and self.sy <= point[2] <= self.ty
def update_intersection(self, intersection, point, horizontal):
sx, tx, sy, ty = intersection
div = point[2 if horizontal else 1]
if horizontal:
return (sx, tx, sy, self.ty >= div) if self.sy <= div else None, \
(sx, tx, self.sy <= div, ty) if self.ty >= div else None
else:
return (sx, self.tx >= div, sy, ty) if self.sx <= div else None, \
(self.sx <= div, tx, sy, ty) if self.tx >= div else None
class Kdt:
def __init__(self, n, points):
self.n = n
self.tree = [None] * n
sorted_point_x = sorted(points, key=lambda p: p[1])
sorted_point_y = sorted(points, key=lambda p: p[2])
self._build(0, sorted_point_y, n, sorted_point_x)
def _build(self, i, points, num, pre_sorted_points):
if 3 * self.exp2m1(num) >= 2 * num - 1: # True if Leaf of complete binary tree ends left side #
rnum = self.exp2m1((num - 1) // 2) # if leaf ends left, right child has (k**2-1) nodes
lnum = num - rnum - 1
else:
lnum = self.exp2m1(num - 1) # if leaf ends right, left child has (k**2-1)nodes
rnum = num - lnum - 1
sorted_points = [p for p in pre_sorted_points if p in points]
self.tree[i] = (sorted_points[lnum], set(p[0] for p in points))
if lnum:
self._build(i * 2 + 1, sorted_points[:lnum], lnum, points)
if rnum:
self._build(i * 2 + 2, sorted_points[lnum + 1:], rnum, points)
def search(self, i, bound, intersection):
if all(intersection):
return self.tree[i][1]
point = self.tree[i][0]
result = {point[0]} if bound.contains(point) else set()
if i * 2 + 1 < self.n:
lis, ris = bound.update_intersection(intersection, point, self.depth(i) & 1)
if lis:
result |= self.search(i * 2 + 1, bound, lis)
if ris and i * 2 + 2 < self.n:
result |= self.search(i * 2 + 2, bound, ris)
return result
@staticmethod
def depth(x):
""" x>=0 """
i = 0
while x:
x //= 2
i += 1
return i
@staticmethod
def exp2m1(x):
n = 1
while n <= (x + 1) // 2:
n *= 2
return n - 1
n = int(input())
point_list = [(i,) + tuple(map(int, input().split())) for i in range(n)]
kdt = Kdt(n, point_list)
q = int(input())
while q:
inside_points = kdt.search(0, Bound(*map(int, input().split())), tuple([False] * 4))
if inside_points:
print('\n'.join(map(str, sorted(inside_points))))
print()
q -= 1
``` | instruction | 0 | 44,622 | 23 | 89,244 |
No | output | 1 | 44,622 | 23 | 89,245 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
The range search problem consists of a set of attributed records S to determine which records from S intersect with a given range.
For n points on a plane, report a set of points which are within in a given range. Note that you do not need to consider insert and delete operations for the set.
Constraints
* 0 ≤ n ≤ 500,000
* 0 ≤ q ≤ 20,000
* -1,000,000,000 ≤ x, y, sx, tx, sy, ty ≤ 1,000,000,000
* sx ≤ tx
* sy ≤ ty
* For each query, the number of points which are within the range is less than or equal to 100.
Input
n
x0 y0
x1 y1
:
xn-1 yn-1
q
sx0 tx0 sy0 ty0
sx1 tx1 sy1 ty1
:
sxq-1 txq-1 syq-1 tyq-1
The first integer n is the number of points. In the following n lines, the coordinate of the i-th point is given by two integers xi and yi.
The next integer q is the number of queries. In the following q lines, each query is given by four integers, sxi, txi, syi, tyi.
Output
For each query, report IDs of points such that sxi ≤ x ≤ txi and syi ≤ y ≤ tyi. The IDs should be reported in ascending order. Print an ID in a line, and print a blank line at the end of output for the each query.
Example
Input
6
2 1
2 2
4 2
6 2
3 3
5 4
2
2 4 0 4
4 10 2 5
Output
0
1
2
4
2
3
5
Submitted Solution:
```
import sys
i_f = sys.stdin
n = int(i_f.readline())
class kdTreeNode:
def __init__(self, input_num, x, y):
self.input_num = input_num
self.x = x
self.y = y
self.left = None
self.right = None
T = [kdTreeNode(i, *map(int, i_f.readline().split())) for i in range(n)]
def make2DTree(l, r, depth):
if l >= r:
return None
mid = (l + r) // 2
if depth % 2 == 0:
T[l:r] = sorted(T[l:r], key=lambda n: n.x)
else:
T[l:r] = sorted(T[l:r], key=lambda n: n.y)
T[mid].left = make2DTree(l, mid, depth + 1)
T[mid].right = make2DTree(mid + 1, r, depth + 1)
return mid
make2DTree(0, n, 0)
def range_search(sx, tx, sy, yx):
ans = []
def _find(v, sx, tx, sy, ty, depth):
node = T[v]
x = node.x
y = node.y
if sx <= x <= tx and sy <= y <= ty:
ans.append(node.input_num)
if depth % 2 == 0:
if node.left != None and sx <= x:
_find(node.left, sx, tx, sy, ty, depth + 1)
if node.right and x <= tx:
_find(node.right, sx, tx, sy, ty, depth + 1)
else:
if node.left != None and sy <= y:
_find(node.left, sx, tx, sy, ty, depth + 1)
if node.right and y <= ty:
_find(node.right, sx, tx, sy, ty, depth + 1)
_find(v, sx, tx, sy, ty, 0)
if ans:
ans.sort()
print(*ans, sep='\n', end='\n\n')
else:
print('')
q = int(i_f.readline())
v = n // 2
for l in i_f:
sx, tx, sy, ty = map(int, l.split())
range_search(sx, tx, sy, ty)
``` | instruction | 0 | 44,623 | 23 | 89,246 |
No | output | 1 | 44,623 | 23 | 89,247 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
The range search problem consists of a set of attributed records S to determine which records from S intersect with a given range.
For n points on a plane, report a set of points which are within in a given range. Note that you do not need to consider insert and delete operations for the set.
Constraints
* 0 ≤ n ≤ 500,000
* 0 ≤ q ≤ 20,000
* -1,000,000,000 ≤ x, y, sx, tx, sy, ty ≤ 1,000,000,000
* sx ≤ tx
* sy ≤ ty
* For each query, the number of points which are within the range is less than or equal to 100.
Input
n
x0 y0
x1 y1
:
xn-1 yn-1
q
sx0 tx0 sy0 ty0
sx1 tx1 sy1 ty1
:
sxq-1 txq-1 syq-1 tyq-1
The first integer n is the number of points. In the following n lines, the coordinate of the i-th point is given by two integers xi and yi.
The next integer q is the number of queries. In the following q lines, each query is given by four integers, sxi, txi, syi, tyi.
Output
For each query, report IDs of points such that sxi ≤ x ≤ txi and syi ≤ y ≤ tyi. The IDs should be reported in ascending order. Print an ID in a line, and print a blank line at the end of output for the each query.
Example
Input
6
2 1
2 2
4 2
6 2
3 3
5 4
2
2 4 0 4
4 10 2 5
Output
0
1
2
4
2
3
5
Submitted Solution:
```
import sys
i_f = sys.stdin
n = int(i_f.readline())
T = []
for i in range(n):
x, y = map(int, i_f.readline().split())
# [3] is left and [4] is right node.
T.append([i, x, y, None, None])
def make2DTree(l, r, depth):
if l >= r:
return None
mid = (l + r) // 2
if depth % 2 == 0:
T[l:r] = sorted(T[l:r], key=lambda n: n[1])
else:
T[l:r] = sorted(T[l:r], key=lambda n: n[2])
T[mid][3] = make2DTree(l, mid, depth + 1)
T[mid][4] = make2DTree(mid + 1, r, depth + 1)
return T[mid]
make2DTree(0, n, 0)
root_node = T[n // 2]
Ans = []
def range_search(sx, tx, sy, yx):
ans = []
def _find(node, sx, tx, sy, ty, depth):
x = node[1]
y = node[2]
if sx <= x <= tx and sy <= y <= ty:
ans.append(node[0])
if depth % 2 == 0:
if node[3] != None and sx <= x:
_find(node[3], sx, tx, sy, ty, depth + 1)
if node[4] and x <= tx:
_find(node[4], sx, tx, sy, ty, depth + 1)
else:
if node[3] != None and sy <= y:
_find(node[3], sx, tx, sy, ty, depth + 1)
if node[4] and y <= ty:
_find(node[4], sx, tx, sy, ty, depth + 1)
_find(root_node, sx, tx, sy, ty, 0)
if ans:
ans.sort()
Ans.extend(ans)
Ans.append('')
q = int(i_f.readline())
for l in i_f:
sx, tx, sy, ty = map(int, l.split())
range_search(sx, tx, sy, ty)
print('\n'.join(map(str, Ans)))
``` | instruction | 0 | 44,624 | 23 | 89,248 |
No | output | 1 | 44,624 | 23 | 89,249 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
The range search problem consists of a set of attributed records S to determine which records from S intersect with a given range.
For n points on a plane, report a set of points which are within in a given range. Note that you do not need to consider insert and delete operations for the set.
Constraints
* 0 ≤ n ≤ 500,000
* 0 ≤ q ≤ 20,000
* -1,000,000,000 ≤ x, y, sx, tx, sy, ty ≤ 1,000,000,000
* sx ≤ tx
* sy ≤ ty
* For each query, the number of points which are within the range is less than or equal to 100.
Input
n
x0 y0
x1 y1
:
xn-1 yn-1
q
sx0 tx0 sy0 ty0
sx1 tx1 sy1 ty1
:
sxq-1 txq-1 syq-1 tyq-1
The first integer n is the number of points. In the following n lines, the coordinate of the i-th point is given by two integers xi and yi.
The next integer q is the number of queries. In the following q lines, each query is given by four integers, sxi, txi, syi, tyi.
Output
For each query, report IDs of points such that sxi ≤ x ≤ txi and syi ≤ y ≤ tyi. The IDs should be reported in ascending order. Print an ID in a line, and print a blank line at the end of output for the each query.
Example
Input
6
2 1
2 2
4 2
6 2
3 3
5 4
2
2 4 0 4
4 10 2 5
Output
0
1
2
4
2
3
5
Submitted Solution:
```
#!/usr/bin/env python
# -*- coding: utf-8 -*-
from sys import stdin
from operator import attrgetter
from collections import namedtuple
class Node(object):
__slots__ = ('location', 'left', 'right')
def __init__(self):
self.location = -1
self.left, self.right = None, None
def make2DTree(left, right, depth):
global np
if not left < right:
return None
mid = (left + right) // 2
cursor = np
np += 1
if depth % 2 == 0:
points_list[left:right] = sorted(points_list[left:right], key=attrgetter('x'))
else:
points_list[left:right] = sorted(points_list[left:right], key=attrgetter('y'))
node_list[cursor].location = mid
node_list[cursor].left = make2DTree(left, mid, depth + 1)
node_list[cursor].right = make2DTree(mid + 1, right, depth + 1)
return cursor
def find(v, sx, tx, sy, ty, depth):
_point = points_list[node_list[v].location]
x, y, p_index = _point.x, _point.y, _point.i
if (sx <= x <= tx) and (sy <= y <= ty):
ans.append(p_index)
if depth % 2 == 0:
if node_list[v].left is not None and sx <= x:
find(node_list[v].left, sx, tx, sy, ty, depth + 1)
if node_list[v].right is not None and x <= tx:
find(node_list[v].right, sx, tx, sy, ty, depth + 1)
else:
if node_list[v].left is not None and sy <= y:
find(node_list[v].left, sx, tx, sy, ty, depth + 1)
if node_list[v].right is not None and y <= ty:
find(node_list[v].right, sx, tx, sy, ty, depth + 1)
return None
def action():
global ans
for area in areas:
sx, tx, sy, ty = map(int, area)
find(root, sx, tx, sy, ty, 0)
print(*sorted(ans), sep='\n')
print('')
ans = []
return None
if __name__ == '__main__':
_input = stdin.readlines()
points_num = int(_input[0])
point = namedtuple('Point', 'i x y')
points_list = [point(i=index, x=int(each[0]), y=int(each[2])) for index, each in
enumerate(_input[1:points_num + 1])]
areas_num = int(_input[points_num + 1])
areas = map(lambda x: x.split(), _input[points_num + 2:])
node_list = [Node() for _ in range(points_num)]
np = 0
ans = []
root = make2DTree(0, points_num, 0)
action()
``` | instruction | 0 | 44,625 | 23 | 89,250 |
No | output | 1 | 44,625 | 23 | 89,251 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
Sasha likes investigating different math objects, for example, magic squares. But Sasha understands that magic squares have already been studied by hundreds of people, so he sees no sense of studying them further. Instead, he invented his own type of square — a prime square.
A square of size n × n is called prime if the following three conditions are held simultaneously:
* all numbers on the square are non-negative integers not exceeding 10^5;
* there are no prime numbers in the square;
* sums of integers in each row and each column are prime numbers.
Sasha has an integer n. He asks you to find any prime square of size n × n. Sasha is absolutely sure such squares exist, so just help him!
Input
The first line contains a single integer t (1 ≤ t ≤ 10) — the number of test cases.
Each of the next t lines contains a single integer n (2 ≤ n ≤ 100) — the required size of a square.
Output
For each test case print n lines, each containing n integers — the prime square you built. If there are multiple answers, print any.
Example
Input
2
4
2
Output
4 6 8 1
4 9 9 9
4 10 10 65
1 4 4 4
1 1
1 1
Submitted Solution:
```
def solve():
n = int(input())
a = [[0] * n for i in range(n)]
for i in range(n):
a[i][i] = 1
a[i][n - i - 1] = 1
if n % 2 == 1:
m = n // 2
a[m][m - 1] = 1
a[m][m + 1] = 1
a[m - 1][m] = 1
a[m + 1][m] = 1
return '\n'.join(' '.join(map(str, r)) for r in a)
t = int(input())
i = 0
while i < t:
print(solve())
i += 1
``` | instruction | 0 | 44,812 | 23 | 89,624 |
Yes | output | 1 | 44,812 | 23 | 89,625 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
Sasha likes investigating different math objects, for example, magic squares. But Sasha understands that magic squares have already been studied by hundreds of people, so he sees no sense of studying them further. Instead, he invented his own type of square — a prime square.
A square of size n × n is called prime if the following three conditions are held simultaneously:
* all numbers on the square are non-negative integers not exceeding 10^5;
* there are no prime numbers in the square;
* sums of integers in each row and each column are prime numbers.
Sasha has an integer n. He asks you to find any prime square of size n × n. Sasha is absolutely sure such squares exist, so just help him!
Input
The first line contains a single integer t (1 ≤ t ≤ 10) — the number of test cases.
Each of the next t lines contains a single integer n (2 ≤ n ≤ 100) — the required size of a square.
Output
For each test case print n lines, each containing n integers — the prime square you built. If there are multiple answers, print any.
Example
Input
2
4
2
Output
4 6 8 1
4 9 9 9
4 10 10 65
1 4 4 4
1 1
1 1
Submitted Solution:
```
import sys
try:sys.stdin,sys.stdout=open('in.txt','r'),open('out.txt','w')
except:pass
ii1=lambda:int(sys.stdin.readline().strip()) # for interger
is1=lambda:sys.stdin.readline().strip() # for str
iia=lambda:list(map(int,sys.stdin.readline().strip().split())) # for List[int]
isa=lambda:sys.stdin.readline().strip().split() # for List[str]
mod=int(1e9 + 7);from collections import *;from math import *
###################### Start Here ######################
for _ in range(ii1()):
n = ii1()
if n==2:
print(1,1)
print(1,1)
elif n==3:
print(1,1,1)
print(1,1,1)
print(1,1,1)
else:
if n%2 == 0:
for i in range(n):
for j in range(n):
if i==j or i==n-j-1:
print(1,end=' ')
else:
print(0,end=' ')
print()
else:
for i in range(n):
for j in range(n):
if i==j or i==n-j-1:
print(1,end=' ')
elif i==0 and j==n//2:
print(1,end=' ')
elif i==n-1 and j==n//2:
print(1,end=' ')
elif j==0 and i==n//2:
print(1,end=' ')
elif j==n-1 and i==n//2:
print(1,end=' ')
else:
print(0,end=' ')
print()
``` | instruction | 0 | 44,813 | 23 | 89,626 |
Yes | output | 1 | 44,813 | 23 | 89,627 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
Sasha likes investigating different math objects, for example, magic squares. But Sasha understands that magic squares have already been studied by hundreds of people, so he sees no sense of studying them further. Instead, he invented his own type of square — a prime square.
A square of size n × n is called prime if the following three conditions are held simultaneously:
* all numbers on the square are non-negative integers not exceeding 10^5;
* there are no prime numbers in the square;
* sums of integers in each row and each column are prime numbers.
Sasha has an integer n. He asks you to find any prime square of size n × n. Sasha is absolutely sure such squares exist, so just help him!
Input
The first line contains a single integer t (1 ≤ t ≤ 10) — the number of test cases.
Each of the next t lines contains a single integer n (2 ≤ n ≤ 100) — the required size of a square.
Output
For each test case print n lines, each containing n integers — the prime square you built. If there are multiple answers, print any.
Example
Input
2
4
2
Output
4 6 8 1
4 9 9 9
4 10 10 65
1 4 4 4
1 1
1 1
Submitted Solution:
```
#!/usr/bin/env python3
import io
import os
import sys
input = io.BytesIO(os.read(0,os.fstat(0).st_size)).readline
def printd(*args, **kwargs):
#print(*args, **kwargs, file=sys.stderr)
print(*args, **kwargs)
pass
def get_str():
return input().decode().strip()
def rint():
return map(int, input().split())
def oint():
return int(input())
t = oint()
for _ in range(t):
n = oint()
line = [0]*n
if n % 2 == 0:
for i in range(n):
line[n-1-i] = 1
line[i] = 1
print(*line)
line[n-1-i] = 0
line[i] = 0
else:
for i in range(n):
if i == n//2 or i == 0 or i == n-1:
line[n//2] = 1
line[0] = 1
line[n-1] = 1
print(*line)
line[n//2] = 0
line[0] = 0
line[n - 1] = 0
else:
line[n-1-i] = 1
line[i] = 1
print(*line)
line[n-1-i] = 0
line[i] = 0
``` | instruction | 0 | 44,814 | 23 | 89,628 |
Yes | output | 1 | 44,814 | 23 | 89,629 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
Sasha likes investigating different math objects, for example, magic squares. But Sasha understands that magic squares have already been studied by hundreds of people, so he sees no sense of studying them further. Instead, he invented his own type of square — a prime square.
A square of size n × n is called prime if the following three conditions are held simultaneously:
* all numbers on the square are non-negative integers not exceeding 10^5;
* there are no prime numbers in the square;
* sums of integers in each row and each column are prime numbers.
Sasha has an integer n. He asks you to find any prime square of size n × n. Sasha is absolutely sure such squares exist, so just help him!
Input
The first line contains a single integer t (1 ≤ t ≤ 10) — the number of test cases.
Each of the next t lines contains a single integer n (2 ≤ n ≤ 100) — the required size of a square.
Output
For each test case print n lines, each containing n integers — the prime square you built. If there are multiple answers, print any.
Example
Input
2
4
2
Output
4 6 8 1
4 9 9 9
4 10 10 65
1 4 4 4
1 1
1 1
Submitted Solution:
```
for t in range(int(input())):
n = int(input())
s = [1,1] + ([0] * (n-2))
for i in range(n):
print(*s)
s = s[-1:] + s[:-1]
``` | instruction | 0 | 44,815 | 23 | 89,630 |
Yes | output | 1 | 44,815 | 23 | 89,631 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
Sasha likes investigating different math objects, for example, magic squares. But Sasha understands that magic squares have already been studied by hundreds of people, so he sees no sense of studying them further. Instead, he invented his own type of square — a prime square.
A square of size n × n is called prime if the following three conditions are held simultaneously:
* all numbers on the square are non-negative integers not exceeding 10^5;
* there are no prime numbers in the square;
* sums of integers in each row and each column are prime numbers.
Sasha has an integer n. He asks you to find any prime square of size n × n. Sasha is absolutely sure such squares exist, so just help him!
Input
The first line contains a single integer t (1 ≤ t ≤ 10) — the number of test cases.
Each of the next t lines contains a single integer n (2 ≤ n ≤ 100) — the required size of a square.
Output
For each test case print n lines, each containing n integers — the prime square you built. If there are multiple answers, print any.
Example
Input
2
4
2
Output
4 6 8 1
4 9 9 9
4 10 10 65
1 4 4 4
1 1
1 1
Submitted Solution:
```
import sys
import math
from collections import Counter,defaultdict
LI=lambda:list(map(int,input().split()))
MAP=lambda:map(int,input().split())
IN=lambda:int(input())
S=lambda:input()
prime = [True for i in range(1000+1)]
def SieveOfEratosthenes(n):
p = 2
while (p * p <= n):
if (prime[p] == True):
for i in range(p * p, n+1, p):
prime[i] = False
p += 1
def case():
n = IN()
x = n-1
for j in range(1,1000):
if prime[x+j]:
break
for i in range(n):
print('1 '*i+str(j)+' 1'*(n-i-1))
for _ in range(IN()):
SieveOfEratosthenes(1000)
case()
``` | instruction | 0 | 44,816 | 23 | 89,632 |
No | output | 1 | 44,816 | 23 | 89,633 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
Sasha likes investigating different math objects, for example, magic squares. But Sasha understands that magic squares have already been studied by hundreds of people, so he sees no sense of studying them further. Instead, he invented his own type of square — a prime square.
A square of size n × n is called prime if the following three conditions are held simultaneously:
* all numbers on the square are non-negative integers not exceeding 10^5;
* there are no prime numbers in the square;
* sums of integers in each row and each column are prime numbers.
Sasha has an integer n. He asks you to find any prime square of size n × n. Sasha is absolutely sure such squares exist, so just help him!
Input
The first line contains a single integer t (1 ≤ t ≤ 10) — the number of test cases.
Each of the next t lines contains a single integer n (2 ≤ n ≤ 100) — the required size of a square.
Output
For each test case print n lines, each containing n integers — the prime square you built. If there are multiple answers, print any.
Example
Input
2
4
2
Output
4 6 8 1
4 9 9 9
4 10 10 65
1 4 4 4
1 1
1 1
Submitted Solution:
```
def inp():
return(int(input()))
def inlt():
return(list(map(int,input().split())))
def insr():
s = input()
return(list(s[:len(s) ]))
def invr():
return(map(int,input().split()))
n = inp()
for _ in range(n):
m = inp()
ans = []
for i in range(m):
#print(ans)
ans.append([])
for j in range(m):
ans[i].append(0)
ans[i][i] = 1
ans[i][-1-i] = 1
#print(ans)
for i in range(m):
res = ''
for x in ans[i]:
res += str(x) + ' '
print(res)
``` | instruction | 0 | 44,817 | 23 | 89,634 |
No | output | 1 | 44,817 | 23 | 89,635 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
Sasha likes investigating different math objects, for example, magic squares. But Sasha understands that magic squares have already been studied by hundreds of people, so he sees no sense of studying them further. Instead, he invented his own type of square — a prime square.
A square of size n × n is called prime if the following three conditions are held simultaneously:
* all numbers on the square are non-negative integers not exceeding 10^5;
* there are no prime numbers in the square;
* sums of integers in each row and each column are prime numbers.
Sasha has an integer n. He asks you to find any prime square of size n × n. Sasha is absolutely sure such squares exist, so just help him!
Input
The first line contains a single integer t (1 ≤ t ≤ 10) — the number of test cases.
Each of the next t lines contains a single integer n (2 ≤ n ≤ 100) — the required size of a square.
Output
For each test case print n lines, each containing n integers — the prime square you built. If there are multiple answers, print any.
Example
Input
2
4
2
Output
4 6 8 1
4 9 9 9
4 10 10 65
1 4 4 4
1 1
1 1
Submitted Solution:
```
for _ in range(int(input())):
n=int(input())
ns=n-0
add=0
if n==1: print(1);continue
else:
while ns%2==0 or ns%3==0 or ns%4==0 or ns%5==0 or ns%6==0 or ns%7==0 or ns%8==0 or ns%9==0:
add+=1; ns+=1
if add%2==0 or add%3==0 or add%4==0 or add%5==0 or add%6==0 or add%7==0 or add%8==0 or add%9==0: continue
else: add+=1; ns+=1
for i in range(n):
for k in range(n):
if k==n-i-1:
print(add+1,end=" ")
else:
print(1,end=" ")
print()
``` | instruction | 0 | 44,818 | 23 | 89,636 |
No | output | 1 | 44,818 | 23 | 89,637 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
Sasha likes investigating different math objects, for example, magic squares. But Sasha understands that magic squares have already been studied by hundreds of people, so he sees no sense of studying them further. Instead, he invented his own type of square — a prime square.
A square of size n × n is called prime if the following three conditions are held simultaneously:
* all numbers on the square are non-negative integers not exceeding 10^5;
* there are no prime numbers in the square;
* sums of integers in each row and each column are prime numbers.
Sasha has an integer n. He asks you to find any prime square of size n × n. Sasha is absolutely sure such squares exist, so just help him!
Input
The first line contains a single integer t (1 ≤ t ≤ 10) — the number of test cases.
Each of the next t lines contains a single integer n (2 ≤ n ≤ 100) — the required size of a square.
Output
For each test case print n lines, each containing n integers — the prime square you built. If there are multiple answers, print any.
Example
Input
2
4
2
Output
4 6 8 1
4 9 9 9
4 10 10 65
1 4 4 4
1 1
1 1
Submitted Solution:
```
import sys, math, itertools, collections, copy
input = sys.stdin.readline
N = 30000
prime = [True] * N
for i in range(2, N):
if prime[i]:
for j in range(i * i, N, i):
prime[j] = False
primes = []
for i in range(2, N):
if prime[i]:
primes.append(i)
diff = []
K = len(primes)
for i in range(1, K):
diff.append(primes[i] - primes[i - 1])
def solve():
n = int(input())
m = [4, 9]
if n != 2:
begin = 5
for i in range(2, n):
m.append(diff[begin])
begin += 1
for i in range(n):
print(*m)
arr = [0] * (len(m))
for i in range(len(m)):
arr[(i + 1) % len(m)] = m[i]
for i in range(len(m)):
m[i] = arr[i]
T = int(input())
for t in range(T):
solve()
``` | instruction | 0 | 44,819 | 23 | 89,638 |
No | output | 1 | 44,819 | 23 | 89,639 |
Provide tags and a correct Python 3 solution for this coding contest problem.
It was decided in IT City to distinguish successes of local IT companies by awards in the form of stars covered with gold from one side. To order the stars it is necessary to estimate order cost that depends on the area of gold-plating. Write a program that can calculate the area of a star.
A "star" figure having n ≥ 5 corners where n is a prime number is constructed the following way. On the circle of radius r n points are selected so that the distances between the adjacent ones are equal. Then every point is connected by a segment with two maximally distant points. All areas bounded by the segments parts are the figure parts.
<image>
Input
The only line of the input contains two integers n (5 ≤ n < 109, n is prime) and r (1 ≤ r ≤ 109) — the number of the star corners and the radius of the circumcircle correspondingly.
Output
Output one number — the star area. The relative error of your answer should not be greater than 10 - 7.
Examples
Input
7 10
Output
108.395919545675 | instruction | 0 | 44,977 | 23 | 89,954 |
Tags: geometry
Correct Solution:
```
import math
n, r = map(int, input().split())
X = 2 * r * math.sin(math.pi / n)
Y = X * math.sin(math.pi * (n - 3) / (2 * n)) / math.sin(3 * math.pi / n)
S1 = 1 / 2 * Y * Y * math.sin(3 * math.pi / n)
S2 = r * r * (math.pi / n - 1 / 2 * math.sin(2 * math.pi / n))
ans = math.pi * r * r - n * (S1 + S2)
print(ans)
``` | output | 1 | 44,977 | 23 | 89,955 |
Provide tags and a correct Python 3 solution for this coding contest problem.
It was decided in IT City to distinguish successes of local IT companies by awards in the form of stars covered with gold from one side. To order the stars it is necessary to estimate order cost that depends on the area of gold-plating. Write a program that can calculate the area of a star.
A "star" figure having n ≥ 5 corners where n is a prime number is constructed the following way. On the circle of radius r n points are selected so that the distances between the adjacent ones are equal. Then every point is connected by a segment with two maximally distant points. All areas bounded by the segments parts are the figure parts.
<image>
Input
The only line of the input contains two integers n (5 ≤ n < 109, n is prime) and r (1 ≤ r ≤ 109) — the number of the star corners and the radius of the circumcircle correspondingly.
Output
Output one number — the star area. The relative error of your answer should not be greater than 10 - 7.
Examples
Input
7 10
Output
108.395919545675 | instruction | 0 | 44,978 | 23 | 89,956 |
Tags: geometry
Correct Solution:
```
import math
n, r = map(int, input().split(' '))
alpha = math.pi/n/2
beta = math.pi/n
gamma = math.pi-alpha-beta
print(r*r*math.sin(alpha)*math.sin(beta)/math.sin(gamma)*n)
``` | output | 1 | 44,978 | 23 | 89,957 |
Provide tags and a correct Python 3 solution for this coding contest problem.
It was decided in IT City to distinguish successes of local IT companies by awards in the form of stars covered with gold from one side. To order the stars it is necessary to estimate order cost that depends on the area of gold-plating. Write a program that can calculate the area of a star.
A "star" figure having n ≥ 5 corners where n is a prime number is constructed the following way. On the circle of radius r n points are selected so that the distances between the adjacent ones are equal. Then every point is connected by a segment with two maximally distant points. All areas bounded by the segments parts are the figure parts.
<image>
Input
The only line of the input contains two integers n (5 ≤ n < 109, n is prime) and r (1 ≤ r ≤ 109) — the number of the star corners and the radius of the circumcircle correspondingly.
Output
Output one number — the star area. The relative error of your answer should not be greater than 10 - 7.
Examples
Input
7 10
Output
108.395919545675 | instruction | 0 | 44,979 | 23 | 89,958 |
Tags: geometry
Correct Solution:
```
import math
Pi = math.pi
n, r = map(float, input().split())
x = math.tan (Pi / n)
y = math.tan (Pi / n / 2)
base = r / (1 / x + 1 / y)
print (n * r * base)
``` | output | 1 | 44,979 | 23 | 89,959 |
Provide tags and a correct Python 3 solution for this coding contest problem.
It was decided in IT City to distinguish successes of local IT companies by awards in the form of stars covered with gold from one side. To order the stars it is necessary to estimate order cost that depends on the area of gold-plating. Write a program that can calculate the area of a star.
A "star" figure having n ≥ 5 corners where n is a prime number is constructed the following way. On the circle of radius r n points are selected so that the distances between the adjacent ones are equal. Then every point is connected by a segment with two maximally distant points. All areas bounded by the segments parts are the figure parts.
<image>
Input
The only line of the input contains two integers n (5 ≤ n < 109, n is prime) and r (1 ≤ r ≤ 109) — the number of the star corners and the radius of the circumcircle correspondingly.
Output
Output one number — the star area. The relative error of your answer should not be greater than 10 - 7.
Examples
Input
7 10
Output
108.395919545675 | instruction | 0 | 44,980 | 23 | 89,960 |
Tags: geometry
Correct Solution:
```
import math as ma
a,b= [int(x) for x in input().split()]
x = ma.pi/a
print((a*(b**2)*(ma.tan(x))*ma.tan(x/2))/(ma.tan(x) + ma.tan(x/2)))
``` | output | 1 | 44,980 | 23 | 89,961 |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.