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 |
|---|---|---|---|---|---|
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
Petya has recently started working as a programmer in the IT city company that develops computer games.
Besides game mechanics implementation to create a game it is necessary to create tool programs that can be used by game designers to create game levels. Petya's first assignment is to create a tool that allows to paint different arrows on the screen.
A user of this tool will choose a point on the screen, specify a vector (the arrow direction) and vary several parameters to get the required graphical effect. In the first version of the program Petya decided to limit parameters of the arrow by the following: a point with coordinates (px, py), a nonzero vector with coordinates (vx, vy), positive scalars a, b, c, d, a > c.
The produced arrow should have the following properties. The arrow consists of a triangle and a rectangle. The triangle is isosceles with base of length a and altitude of length b perpendicular to the base. The rectangle sides lengths are c and d. Point (px, py) is situated in the middle of the triangle base and in the middle of side of rectangle that has length c. Area of intersection of the triangle and the rectangle is zero. The direction from (px, py) point to the triangle vertex opposite to base containing the point coincides with direction of (vx, vy) vector.
Enumerate the arrow points coordinates in counter-clockwise order starting from the tip.
<image>
Input
The only line of the input contains eight integers px, py, vx, vy ( - 1000 ≤ px, py, vx, vy ≤ 1000, vx2 + vy2 > 0), a, b, c, d (1 ≤ a, b, c, d ≤ 1000, a > c).
Output
Output coordinates of the arrow points in counter-clockwise order. Each line should contain two coordinates, first x, then y. Relative or absolute error should not be greater than 10 - 9.
Examples
Input
8 8 0 2 8 3 4 5
Output
8.000000000000 11.000000000000
4.000000000000 8.000000000000
6.000000000000 8.000000000000
6.000000000000 3.000000000000
10.000000000000 3.000000000000
10.000000000000 8.000000000000
12.000000000000 8.000000000000
Submitted Solution:
```
import math
from decimal import Decimal
px,py,vx,vy,a,b,c,d = map(Decimal, input().split())
h = (vx**2 + vy**2).sqrt()
vx, vy = vx / h, vy / h
print("%0.60f %0.60f" % tuple(map(lambda x: round(x, 14), [px + vx * b, py + vy * b])))
print("%0.60f %0.60f" % tuple(map(lambda x: round(x, 14), [px - a/2 * vy, py + a/2 * vx])))
print("%0.60f %0.60f" % tuple(map(lambda x: round(x, 14), [px - c / 2 * vy, px + c / 2 * vx])))
#print("%0.60f %0.60f" % tuple(map(lambda x: round(x, 10),[(px + vx * b, py + vy * b])))
#print("%0.60f %0.60f" % tuple(map(lambda x: round(x, 10),[(px + vx * b, py + vy * b])))
print("%0.60f %0.60f" % tuple(map(lambda x: round(x, 14), [px - c / 2 * vy - d * vx, px + c / 2 * vx - d*vy])))
print("%0.60f %0.60f" % tuple(map(lambda x: round(x, 14), [px + c / 2 * vy - d * vx, px - c / 2 * vx - d*vy])))
print("%0.60f %0.60f" % tuple(map(lambda x: round(x, 14), [px + c / 2 * vy, px - c / 2 * vx])))
print("%0.60f %0.60f" % tuple(map(lambda x: round(x, 14), [px + a/2 * vy, py - a/2 * vx])))
``` | instruction | 0 | 53,510 | 23 | 107,020 |
No | output | 1 | 53,510 | 23 | 107,021 |
Provide tags and a correct Python 3 solution for this coding contest problem.
There are n points marked on the plane. The points are situated in such a way that they form a regular polygon (marked points are its vertices, and they are numbered in counter-clockwise order). You can draw n - 1 segments, each connecting any two marked points, in such a way that all points have to be connected with each other (directly or indirectly).
But there are some restrictions. Firstly, some pairs of points cannot be connected directly and have to be connected undirectly. Secondly, the segments you draw must not intersect in any point apart from the marked points (that is, if any two segments intersect and their intersection is not a marked point, then the picture you have drawn is invalid).
How many ways are there to connect all vertices with n - 1 segments? Two ways are considered different iff there exist some pair of points such that a segment is drawn between them in the first way of connection, but it is not drawn between these points in the second one. Since the answer might be large, output it modulo 109 + 7.
Input
The first line contains one number n (3 ≤ n ≤ 500) — the number of marked points.
Then n lines follow, each containing n elements. ai, j (j-th element of line i) is equal to 1 iff you can connect points i and j directly (otherwise ai, j = 0). It is guaranteed that for any pair of points ai, j = aj, i, and for any point ai, i = 0.
Output
Print the number of ways to connect points modulo 109 + 7.
Examples
Input
3
0 0 1
0 0 1
1 1 0
Output
1
Input
4
0 1 1 1
1 0 1 1
1 1 0 1
1 1 1 0
Output
12
Input
3
0 0 0
0 0 1
0 1 0
Output
0 | instruction | 0 | 53,603 | 23 | 107,206 |
Tags: dp, graphs
Correct Solution:
```
import sys
from array import array
n = int(input())
edge = [list(map(int, input().split())) for _ in range(n)]
mod = 10**9 + 7
dp_f = [array('i', [-1])*n for _ in range(n)]
dp_g = [array('i', [-1])*n for _ in range(n)]
for i in range(n):
dp_f[i][i] = dp_g[i][i] = 1
for i in range(n-1):
dp_f[i][i+1] = dp_g[i][i+1] = 1 if edge[i][i+1] else 0
def f(l, r):
if dp_f[l][r] != -1:
return dp_f[l][r]
dp_f[l][r] = g(l, r) if edge[l][r] else 0
for m in range(l+1, r):
if edge[l][m]:
dp_f[l][r] = (dp_f[l][r] + g(l, m) * f(m, r)) % mod
return dp_f[l][r]
def g(l, r):
if dp_g[l][r] != -1:
return dp_g[l][r]
dp_g[l][r] = f(l+1, r)
for m in range(l+1, r):
dp_g[l][r] = (dp_g[l][r] + f(l, m) * f(m+1, r)) % mod
return dp_g[l][r]
print(f(0, n-1))
``` | output | 1 | 53,603 | 23 | 107,207 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
There are n points marked on the plane. The points are situated in such a way that they form a regular polygon (marked points are its vertices, and they are numbered in counter-clockwise order). You can draw n - 1 segments, each connecting any two marked points, in such a way that all points have to be connected with each other (directly or indirectly).
But there are some restrictions. Firstly, some pairs of points cannot be connected directly and have to be connected undirectly. Secondly, the segments you draw must not intersect in any point apart from the marked points (that is, if any two segments intersect and their intersection is not a marked point, then the picture you have drawn is invalid).
How many ways are there to connect all vertices with n - 1 segments? Two ways are considered different iff there exist some pair of points such that a segment is drawn between them in the first way of connection, but it is not drawn between these points in the second one. Since the answer might be large, output it modulo 109 + 7.
Input
The first line contains one number n (3 ≤ n ≤ 500) — the number of marked points.
Then n lines follow, each containing n elements. ai, j (j-th element of line i) is equal to 1 iff you can connect points i and j directly (otherwise ai, j = 0). It is guaranteed that for any pair of points ai, j = aj, i, and for any point ai, i = 0.
Output
Print the number of ways to connect points modulo 109 + 7.
Examples
Input
3
0 0 1
0 0 1
1 1 0
Output
1
Input
4
0 1 1 1
1 0 1 1
1 1 0 1
1 1 1 0
Output
12
Input
3
0 0 0
0 0 1
0 1 0
Output
0
Submitted Solution:
```
import sys
n = int(input())
edge = [list(map(int, input().split())) for _ in range(n)]
mod = 10**9 + 7
dp_f = [[-1]*n for _ in range(n)]
dp_g = [[-1]*n for _ in range(n)]
for i in range(n):
dp_f[i][i] = dp_g[i][i] = 1
for i in range(n-1):
if edge[i][i+1]:
dp_f[i][i+1] = dp_g[i][i+1] = 1
def f(l, r):
if dp_f[l][r] != -1:
return dp_f[l][r]
dp_f[l][r] = g(l, r)
for m in range(l+1, r):
if edge[l][m]:
dp_f[l][r] += g(l, m) * f(m, r)
dp_f[l][r] %= mod
return dp_f[l][r]
def g(l, r):
if dp_g[l][r] != -1:
return dp_g[l][r]
dp_g[l][r] = f(l+1, r)
for m in range(l+1, r):
dp_g[l][r] += f(l, m) * f(m+1, r)
dp_g[l][r] %= mod
return dp_g[l][r]
print(f(0, n-1))
``` | instruction | 0 | 53,604 | 23 | 107,208 |
No | output | 1 | 53,604 | 23 | 107,209 |
Provide a correct Python 3 solution for this coding contest problem.
There are N lines in the xy-plane. The i-th line is represented by A_ix+B_iy=C_i. Any two lines among the N+2 lines, the above N lines plus the x-axis and y-axis, cross each other at exactly one point.
For each pair 1 \leq i < j \leq N, there is a car at the cross point of the i-th and j-th lines. Even where three or more lines intersect at a point, a car is individually placed for each pair of lines. That is, there will be k(k-1)/2 cars placed at the intersection of k lines.
Those cars are already very old, and can only be moved parallel to the x-axis or y-axis.
Takahashi will hold an exhibition of antique cars at a place on the xy-plane. In order to avoid damaging the half-broken cars too much, he will select the place of the exhibition so that the total distance covered will be minimized when all the cars are moved to the place. If such a place is not uniquely determined, among the places that satisfy the condition above, the place with the minimum x-coordinate will be selected. If the place is still not uniquely determined, among the places that satisfy the two conditions above, the place with the minimum y-coordinate will be selected.
Find the place of the exhibition that will be selected.
Constraints
* 2 \leq N \leq 4 × 10^4
* 1 \leq |A_i|,|B_i| \leq 10^4(1 \leq i \leq N)
* 0 \leq |C_i| \leq 10^4(1 \leq i \leq N)
* No two given lines are parallel.
* All input values are integers.
Inputs
Input is given from Standard Input in the following format:
N
A_1 B_1 C_1
:
A_N B_N C_N
Outputs
Print the x-coordinate and y-coordinate of the place of the exhibition that will be selected, in this order, with a space in between. The output will be judged as correct when the absolute or relative error is at most 10^{-9}.
Examples
Input
3
1 1 1
2 -1 2
-1 2 2
Output
1.000000000000000 1.000000000000000
Input
4
1 1 2
1 -1 0
3 -1 -2
1 -3 4
Output
-1.000000000000000 -1.000000000000000
Input
7
1 7 8
-2 4 9
3 -8 -5
9 2 -14
6 7 5
-8 -9 3
3 8 10
Output
-1.722222222222222 1.325000000000000 | instruction | 0 | 53,767 | 23 | 107,534 |
"Correct Solution:
```
def addbit(i):
i += 1
while i <= N:
BIT[i] += 1
i += i & (-i)
def getsum(i):
ret = 0
i += 1
while i != 0:
ret += BIT[i]
i -= i&(-i)
return ret
def bit(L):
global BIT
BIT=[0] * (N+1)
re = 0
for l in L:
re += getsum(l)
addbit(l)
return N*(N-1)//2 - re
def get_rank(L):
D = {x:i for i,x in enumerate(sorted(L))}
return [D[x] for x in L]
def calc(Z):
Z.sort()
l, r, lc, rc = -1<<28, 1<<28, N*(N-1)//4+1, N*(N-1)//4+1
while (r - l) / max(abs(l), 1) > 0.000000001:
m = (l * rc + r * lc) / (lc + rc)
A = get_rank([s*m+t for s, t in Z])
c = bit(A)
if c > N*(N-1)//4:
l = m
lc = ((c - N*(N-1)//4) * 2) ** 0.2
else:
r = m
rc = ((N*(N-1)//4 - c) * 2 + 1) ** 0.2
return l
N = int(input())
X, Y = [], []
for _ in range(N):
a, b, c = map(int, input().split())
X.append((-a/b, c/b))
Y.append((-b/a, c/a))
print(calc(X), calc(Y))
``` | output | 1 | 53,767 | 23 | 107,535 |
Provide a correct Python 3 solution for this coding contest problem.
There are N lines in the xy-plane. The i-th line is represented by A_ix+B_iy=C_i. Any two lines among the N+2 lines, the above N lines plus the x-axis and y-axis, cross each other at exactly one point.
For each pair 1 \leq i < j \leq N, there is a car at the cross point of the i-th and j-th lines. Even where three or more lines intersect at a point, a car is individually placed for each pair of lines. That is, there will be k(k-1)/2 cars placed at the intersection of k lines.
Those cars are already very old, and can only be moved parallel to the x-axis or y-axis.
Takahashi will hold an exhibition of antique cars at a place on the xy-plane. In order to avoid damaging the half-broken cars too much, he will select the place of the exhibition so that the total distance covered will be minimized when all the cars are moved to the place. If such a place is not uniquely determined, among the places that satisfy the condition above, the place with the minimum x-coordinate will be selected. If the place is still not uniquely determined, among the places that satisfy the two conditions above, the place with the minimum y-coordinate will be selected.
Find the place of the exhibition that will be selected.
Constraints
* 2 \leq N \leq 4 × 10^4
* 1 \leq |A_i|,|B_i| \leq 10^4(1 \leq i \leq N)
* 0 \leq |C_i| \leq 10^4(1 \leq i \leq N)
* No two given lines are parallel.
* All input values are integers.
Inputs
Input is given from Standard Input in the following format:
N
A_1 B_1 C_1
:
A_N B_N C_N
Outputs
Print the x-coordinate and y-coordinate of the place of the exhibition that will be selected, in this order, with a space in between. The output will be judged as correct when the absolute or relative error is at most 10^{-9}.
Examples
Input
3
1 1 1
2 -1 2
-1 2 2
Output
1.000000000000000 1.000000000000000
Input
4
1 1 2
1 -1 0
3 -1 -2
1 -3 4
Output
-1.000000000000000 -1.000000000000000
Input
7
1 7 8
-2 4 9
3 -8 -5
9 2 -14
6 7 5
-8 -9 3
3 8 10
Output
-1.722222222222222 1.325000000000000 | instruction | 0 | 53,768 | 23 | 107,536 |
"Correct Solution:
```
def addbit(i):
i += 1
while i <= N:
BIT[i] += 1
i += i & (-i)
def getsum(i):
ret = 0
i += 1
while i != 0:
ret += BIT[i]
i -= i&(-i)
return ret
def bit(L):
global BIT
BIT=[0] * (N+1)
re = 0
for l in L:
re += getsum(l)
addbit(l)
return N*(N-1)//2 - re
def get_rank(L):
D = {x:i for i,x in enumerate(sorted(L))}
return [D[x] for x in L]
def calc(Z):
Z.sort()
l, r, lc, rc = -1<<28, 1<<28, N*(N-1)//4+1, N*(N-1)//4+1
while (r - l) / max(min(abs(l), abs(r)), 1) > 0.000000002:
m = (l * rc + r * lc) / (lc + rc)
A = get_rank([s*m+t for s, t in Z])
c = bit(A)
if c > N*(N-1)//4:
l = m
lc = ((c - N*(N-1)//4) * 2) ** 0.3
else:
r = m
rc = ((N*(N-1)//4 - c) * 2 + 1) ** 0.3
return (l+r) / 2
N = int(input())
X, Y = [], []
for _ in range(N):
a, b, c = map(int, input().split())
X.append((-a/b, c/b))
Y.append((-b/a, c/a))
print(calc(X), calc(Y))
``` | output | 1 | 53,768 | 23 | 107,537 |
Provide a correct Python 3 solution for this coding contest problem.
There are N lines in the xy-plane. The i-th line is represented by A_ix+B_iy=C_i. Any two lines among the N+2 lines, the above N lines plus the x-axis and y-axis, cross each other at exactly one point.
For each pair 1 \leq i < j \leq N, there is a car at the cross point of the i-th and j-th lines. Even where three or more lines intersect at a point, a car is individually placed for each pair of lines. That is, there will be k(k-1)/2 cars placed at the intersection of k lines.
Those cars are already very old, and can only be moved parallel to the x-axis or y-axis.
Takahashi will hold an exhibition of antique cars at a place on the xy-plane. In order to avoid damaging the half-broken cars too much, he will select the place of the exhibition so that the total distance covered will be minimized when all the cars are moved to the place. If such a place is not uniquely determined, among the places that satisfy the condition above, the place with the minimum x-coordinate will be selected. If the place is still not uniquely determined, among the places that satisfy the two conditions above, the place with the minimum y-coordinate will be selected.
Find the place of the exhibition that will be selected.
Constraints
* 2 \leq N \leq 4 × 10^4
* 1 \leq |A_i|,|B_i| \leq 10^4(1 \leq i \leq N)
* 0 \leq |C_i| \leq 10^4(1 \leq i \leq N)
* No two given lines are parallel.
* All input values are integers.
Inputs
Input is given from Standard Input in the following format:
N
A_1 B_1 C_1
:
A_N B_N C_N
Outputs
Print the x-coordinate and y-coordinate of the place of the exhibition that will be selected, in this order, with a space in between. The output will be judged as correct when the absolute or relative error is at most 10^{-9}.
Examples
Input
3
1 1 1
2 -1 2
-1 2 2
Output
1.000000000000000 1.000000000000000
Input
4
1 1 2
1 -1 0
3 -1 -2
1 -3 4
Output
-1.000000000000000 -1.000000000000000
Input
7
1 7 8
-2 4 9
3 -8 -5
9 2 -14
6 7 5
-8 -9 3
3 8 10
Output
-1.722222222222222 1.325000000000000 | instruction | 0 | 53,769 | 23 | 107,538 |
"Correct Solution:
```
def addbit(i):
i += 1
while i <= N:
BIT[i] += 1
i += i & (-i)
def getsum(i):
ret = 0
i += 1
while i != 0:
ret += BIT[i]
i -= i&(-i)
return ret
def bit(L):
global BIT
BIT=[0] * (N+1)
re = 0
for l in L:
re += getsum(l)
addbit(l)
return N*(N-1)//2 - re
def get_rank(L):
D = {x:i for i,x in enumerate(sorted(L))}
return [D[x] for x in L]
def calc(Z):
Z.sort()
l, r = -1<<28, 1<<28
while (r - l) / max(abs(l), 1) > 0.000000001:
m = (l+r)/2
A = get_rank([s*m+t for s, t in Z])
c = bit(A)
if c > N*(N-1)//4:
l = m
else:
r = m
return l
N = int(input())
X, Y = [], []
for _ in range(N):
a, b, c = map(int, input().split())
X.append((-a/b, c/b))
Y.append((-b/a, c/a))
print(calc(X), calc(Y))
``` | output | 1 | 53,769 | 23 | 107,539 |
Provide a correct Python 3 solution for this coding contest problem.
There are N lines in the xy-plane. The i-th line is represented by A_ix+B_iy=C_i. Any two lines among the N+2 lines, the above N lines plus the x-axis and y-axis, cross each other at exactly one point.
For each pair 1 \leq i < j \leq N, there is a car at the cross point of the i-th and j-th lines. Even where three or more lines intersect at a point, a car is individually placed for each pair of lines. That is, there will be k(k-1)/2 cars placed at the intersection of k lines.
Those cars are already very old, and can only be moved parallel to the x-axis or y-axis.
Takahashi will hold an exhibition of antique cars at a place on the xy-plane. In order to avoid damaging the half-broken cars too much, he will select the place of the exhibition so that the total distance covered will be minimized when all the cars are moved to the place. If such a place is not uniquely determined, among the places that satisfy the condition above, the place with the minimum x-coordinate will be selected. If the place is still not uniquely determined, among the places that satisfy the two conditions above, the place with the minimum y-coordinate will be selected.
Find the place of the exhibition that will be selected.
Constraints
* 2 \leq N \leq 4 × 10^4
* 1 \leq |A_i|,|B_i| \leq 10^4(1 \leq i \leq N)
* 0 \leq |C_i| \leq 10^4(1 \leq i \leq N)
* No two given lines are parallel.
* All input values are integers.
Inputs
Input is given from Standard Input in the following format:
N
A_1 B_1 C_1
:
A_N B_N C_N
Outputs
Print the x-coordinate and y-coordinate of the place of the exhibition that will be selected, in this order, with a space in between. The output will be judged as correct when the absolute or relative error is at most 10^{-9}.
Examples
Input
3
1 1 1
2 -1 2
-1 2 2
Output
1.000000000000000 1.000000000000000
Input
4
1 1 2
1 -1 0
3 -1 -2
1 -3 4
Output
-1.000000000000000 -1.000000000000000
Input
7
1 7 8
-2 4 9
3 -8 -5
9 2 -14
6 7 5
-8 -9 3
3 8 10
Output
-1.722222222222222 1.325000000000000 | instruction | 0 | 53,770 | 23 | 107,540 |
"Correct Solution:
```
def addbit(i):
i += 1
while i <= N:
BIT[i] += 1
i += i & (-i)
def getsum(i):
ret = 0
i += 1
while i != 0:
ret += BIT[i]
i -= i&(-i)
return ret
def bit(L):
global BIT
BIT=[0] * (N+1)
re = 0
for l in L:
re += getsum(l)
addbit(l)
return N*(N-1)//2 - re
def get_rank(L):
D = {x:i for i,x in enumerate(sorted(L))}
return [D[x] for x in L]
def calc(Z):
Z.sort()
l, r, lc, rc = -1<<28, 1<<28, N*(N-1)//4+1, N*(N-1)//4+1
while (r - l) / max(abs(l), 1) > 0.000000001:
m = (l * rc + r * lc) / (lc + rc)
A = get_rank([s*m+t for s, t in Z])
c = bit(A)
if c > N*(N-1)//4:
l = m
lc = ((c - N*(N-1)//4) * 2) ** 0.6
else:
r = m
rc = ((N*(N-1)//4 - c) * 2 + 1) ** 0.6
return l
N = int(input())
X, Y = [], []
for _ in range(N):
a, b, c = map(int, input().split())
X.append((-a/b, c/b))
Y.append((-b/a, c/a))
print(calc(X), calc(Y))
``` | output | 1 | 53,770 | 23 | 107,541 |
Provide a correct Python 3 solution for this coding contest problem.
There are N lines in the xy-plane. The i-th line is represented by A_ix+B_iy=C_i. Any two lines among the N+2 lines, the above N lines plus the x-axis and y-axis, cross each other at exactly one point.
For each pair 1 \leq i < j \leq N, there is a car at the cross point of the i-th and j-th lines. Even where three or more lines intersect at a point, a car is individually placed for each pair of lines. That is, there will be k(k-1)/2 cars placed at the intersection of k lines.
Those cars are already very old, and can only be moved parallel to the x-axis or y-axis.
Takahashi will hold an exhibition of antique cars at a place on the xy-plane. In order to avoid damaging the half-broken cars too much, he will select the place of the exhibition so that the total distance covered will be minimized when all the cars are moved to the place. If such a place is not uniquely determined, among the places that satisfy the condition above, the place with the minimum x-coordinate will be selected. If the place is still not uniquely determined, among the places that satisfy the two conditions above, the place with the minimum y-coordinate will be selected.
Find the place of the exhibition that will be selected.
Constraints
* 2 \leq N \leq 4 × 10^4
* 1 \leq |A_i|,|B_i| \leq 10^4(1 \leq i \leq N)
* 0 \leq |C_i| \leq 10^4(1 \leq i \leq N)
* No two given lines are parallel.
* All input values are integers.
Inputs
Input is given from Standard Input in the following format:
N
A_1 B_1 C_1
:
A_N B_N C_N
Outputs
Print the x-coordinate and y-coordinate of the place of the exhibition that will be selected, in this order, with a space in between. The output will be judged as correct when the absolute or relative error is at most 10^{-9}.
Examples
Input
3
1 1 1
2 -1 2
-1 2 2
Output
1.000000000000000 1.000000000000000
Input
4
1 1 2
1 -1 0
3 -1 -2
1 -3 4
Output
-1.000000000000000 -1.000000000000000
Input
7
1 7 8
-2 4 9
3 -8 -5
9 2 -14
6 7 5
-8 -9 3
3 8 10
Output
-1.722222222222222 1.325000000000000 | instruction | 0 | 53,771 | 23 | 107,542 |
"Correct Solution:
```
class Bit:
# 参考1: http://hos.ac/slides/20140319_bit.pdf
# 参考2: https://atcoder.jp/contests/arc046/submissions/6264201
# 検証: https://atcoder.jp/contests/arc046/submissions/7435621
# values の 0 番目は使わない
# len(values) を 2 冪 +1 にすることで二分探索の条件を減らす
def __init__(self, a):
if hasattr(a, "__iter__"):
le = len(a)
self.n = 1 << le.bit_length() # le を超える最小の 2 冪
self.values = values = [0] * (self.n + 1)
values[1:le + 1] = a[:]
for i in range(1, self.n):
values[i + (i & -i)] += values[i]
elif isinstance(a, int):
self.n = 1 << a.bit_length()
self.values = [0] * (self.n + 1)
else:
raise TypeError
def add(self, i, val):
n, values = self.n, self.values
while i <= n:
values[i] += val
i += i & -i
def sum(self, i): # (0, i]
values = self.values
res = 0
while i > 0:
res += values[i]
i -= i & -i
return res
def bisect_left(self, v): # self.sum(i) が v 以上になる最小の i
n, values = self.n, self.values
if v > values[n]:
return None
i, step = 0, n >> 1
while step:
if values[i + step] < v:
i += step
v -= values[i]
step >>= 1
return i + 1
def inversion_number(arr):
n = len(arr)
arr = sorted(range(n), key=lambda x: arr[x])
bit = Bit(n)
res = n * (n-1) >> 1
for val in arr:
res -= bit.sum(val+1)
bit.add(val+1, 1)
return res
N = int(input())
ABC = [list(map(int, input().split())) for _ in range(N)]
A, B, C = zip(*ABC)
th = N*(N-1)//2 // 2 + 1
def solve(A, B, C):
# y = (-Ax+C) / B
if N < 100:
ok = -1e10
ng = 1e10
n_iteration = 70
else:
ok = -1e4
ng = 1e4
n_iteration = 46
A, B, C = zip(*sorted(zip(A, B, C), key=lambda x: -x[0]/x[1]))
for _ in range(n_iteration):
x = (ok+ng) * 0.5
Y = [(-a*x+c)/b for a, b, c in zip(A, B, C)]
inv_num = inversion_number(Y)
if inv_num >= th:
ok = x
else:
ng = x
return ok
print(solve(A, B, C), solve(B, A, C))
``` | output | 1 | 53,771 | 23 | 107,543 |
Provide a correct Python 3 solution for this coding contest problem.
There are N lines in the xy-plane. The i-th line is represented by A_ix+B_iy=C_i. Any two lines among the N+2 lines, the above N lines plus the x-axis and y-axis, cross each other at exactly one point.
For each pair 1 \leq i < j \leq N, there is a car at the cross point of the i-th and j-th lines. Even where three or more lines intersect at a point, a car is individually placed for each pair of lines. That is, there will be k(k-1)/2 cars placed at the intersection of k lines.
Those cars are already very old, and can only be moved parallel to the x-axis or y-axis.
Takahashi will hold an exhibition of antique cars at a place on the xy-plane. In order to avoid damaging the half-broken cars too much, he will select the place of the exhibition so that the total distance covered will be minimized when all the cars are moved to the place. If such a place is not uniquely determined, among the places that satisfy the condition above, the place with the minimum x-coordinate will be selected. If the place is still not uniquely determined, among the places that satisfy the two conditions above, the place with the minimum y-coordinate will be selected.
Find the place of the exhibition that will be selected.
Constraints
* 2 \leq N \leq 4 × 10^4
* 1 \leq |A_i|,|B_i| \leq 10^4(1 \leq i \leq N)
* 0 \leq |C_i| \leq 10^4(1 \leq i \leq N)
* No two given lines are parallel.
* All input values are integers.
Inputs
Input is given from Standard Input in the following format:
N
A_1 B_1 C_1
:
A_N B_N C_N
Outputs
Print the x-coordinate and y-coordinate of the place of the exhibition that will be selected, in this order, with a space in between. The output will be judged as correct when the absolute or relative error is at most 10^{-9}.
Examples
Input
3
1 1 1
2 -1 2
-1 2 2
Output
1.000000000000000 1.000000000000000
Input
4
1 1 2
1 -1 0
3 -1 -2
1 -3 4
Output
-1.000000000000000 -1.000000000000000
Input
7
1 7 8
-2 4 9
3 -8 -5
9 2 -14
6 7 5
-8 -9 3
3 8 10
Output
-1.722222222222222 1.325000000000000 | instruction | 0 | 53,772 | 23 | 107,544 |
"Correct Solution:
```
def addbit(i):
i += 1
while i <= N:
BIT[i] += 1
i += i & (-i)
def getsum(i):
ret = 0
i += 1
while i != 0:
ret += BIT[i]
i -= i&(-i)
return ret
def bit(L):
global BIT
BIT=[0] * (N+1)
re = 0
for l in L:
re += getsum(l)
addbit(l)
return N*(N-1)//2 - re
def get_rank(L):
D = {x:i for i,x in enumerate(sorted(L))}
return [D[x] for x in L]
def calc(Z):
Z.sort()
l, r, lc, rc = -1<<28, 1<<28, N*(N-1)//4+1, N*(N-1)//4+1
while (r - l) / max(abs(l), 1) > 0.000000001:
m = (l * rc + r * lc) / (lc + rc)
A = get_rank([s*m+t for s, t in Z])
c = bit(A)
if c > N*(N-1)//4:
l = m
lc = ((c - N*(N-1)//4) * 2) ** 0.3
else:
r = m
rc = ((N*(N-1)//4 - c) * 2 + 1) ** 0.3
return l
N = int(input())
X, Y = [], []
for _ in range(N):
a, b, c = map(int, input().split())
X.append((-a/b, c/b))
Y.append((-b/a, c/a))
print(calc(X), calc(Y))
``` | output | 1 | 53,772 | 23 | 107,545 |
Provide a correct Python 3 solution for this coding contest problem.
There are N lines in the xy-plane. The i-th line is represented by A_ix+B_iy=C_i. Any two lines among the N+2 lines, the above N lines plus the x-axis and y-axis, cross each other at exactly one point.
For each pair 1 \leq i < j \leq N, there is a car at the cross point of the i-th and j-th lines. Even where three or more lines intersect at a point, a car is individually placed for each pair of lines. That is, there will be k(k-1)/2 cars placed at the intersection of k lines.
Those cars are already very old, and can only be moved parallel to the x-axis or y-axis.
Takahashi will hold an exhibition of antique cars at a place on the xy-plane. In order to avoid damaging the half-broken cars too much, he will select the place of the exhibition so that the total distance covered will be minimized when all the cars are moved to the place. If such a place is not uniquely determined, among the places that satisfy the condition above, the place with the minimum x-coordinate will be selected. If the place is still not uniquely determined, among the places that satisfy the two conditions above, the place with the minimum y-coordinate will be selected.
Find the place of the exhibition that will be selected.
Constraints
* 2 \leq N \leq 4 × 10^4
* 1 \leq |A_i|,|B_i| \leq 10^4(1 \leq i \leq N)
* 0 \leq |C_i| \leq 10^4(1 \leq i \leq N)
* No two given lines are parallel.
* All input values are integers.
Inputs
Input is given from Standard Input in the following format:
N
A_1 B_1 C_1
:
A_N B_N C_N
Outputs
Print the x-coordinate and y-coordinate of the place of the exhibition that will be selected, in this order, with a space in between. The output will be judged as correct when the absolute or relative error is at most 10^{-9}.
Examples
Input
3
1 1 1
2 -1 2
-1 2 2
Output
1.000000000000000 1.000000000000000
Input
4
1 1 2
1 -1 0
3 -1 -2
1 -3 4
Output
-1.000000000000000 -1.000000000000000
Input
7
1 7 8
-2 4 9
3 -8 -5
9 2 -14
6 7 5
-8 -9 3
3 8 10
Output
-1.722222222222222 1.325000000000000 | instruction | 0 | 53,773 | 23 | 107,546 |
"Correct Solution:
```
import sys
readline = sys.stdin.readline
class BIT:
#1-indexed
def __init__(self, n):
self.size = n
self.tree = [0] * (n + 1)
self.p = 2**(n.bit_length() - 1)
self.dep = n.bit_length()
def get(self, i):
s = 0
while i > 0:
s += self.tree[i]
i -= i & -i
return s
def add(self, i, x):
while i <= self.size:
self.tree[i] += x
i += i & -i
def bl(self, v):
if v <= 0:
return -1
s = 0
k = self.p
for _ in range(self.dep):
if s + k <= self.size and self.tree[s+k] < v:
s += k
v -= self.tree[s+k]
k //= 2
return s + 1
def reset(self):
self.tree = [0]*(self.size+1)
N = int(readline())
INF = 2e8 + 10
EPS = 1e-9
Points = [tuple(map(int, readline().split())) for _ in range(N)]
Points.sort(key = lambda x: -x[0]/x[1])
XA = [-a/b for a, b, _ in Points]
XB = [c/b for _, b, c in Points]
Points.sort(key = lambda x: -x[1]/x[0])
YA = [-b/a for a, b, _ in Points]
YB = [c/a for a, _, c in Points]
con = -(-N*(N-1)//4)
T = BIT(N)
ng = -INF
ok = INF
nf = con
of = con
while abs(ok-ng)/max(1, min(abs(ok), abs(ng))) > EPS:
med = (ok*nf+ng*of)/(of+nf)
T.reset()
res = 0
for idx in sorted(range(N), key = lambda x: XA[x]*med + XB[x]):
res += T.get(idx+1)
T.add(idx+1, 1)
if res >= con:
ok = med
of = ((res - con)*2 + 1) ** 0.3
else:
ng = med
nf = ((con - res)*2) ** 0.3
X = ok
ng = -INF
ok = INF
nf = con
of = con
cnt = 1
while abs(ok-ng)/max(1, min(abs(ok), abs(ng))) > EPS:
cnt += 1
med = (ok*nf+ng*of)/(of+nf)
T.reset()
res = 0
for idx in sorted(range(N), key = lambda x: YA[x]*med + YB[x]):
res += T.get(idx+1)
T.add(idx+1, 1)
if res >= con:
ok = med
of = ((res - con)*2 + 1) ** 0.3
else:
ng = med
nf = ((con - res)*2) ** 0.3
Y = ok
print(X, Y)
``` | output | 1 | 53,773 | 23 | 107,547 |
Provide a correct Python 3 solution for this coding contest problem.
There are N lines in the xy-plane. The i-th line is represented by A_ix+B_iy=C_i. Any two lines among the N+2 lines, the above N lines plus the x-axis and y-axis, cross each other at exactly one point.
For each pair 1 \leq i < j \leq N, there is a car at the cross point of the i-th and j-th lines. Even where three or more lines intersect at a point, a car is individually placed for each pair of lines. That is, there will be k(k-1)/2 cars placed at the intersection of k lines.
Those cars are already very old, and can only be moved parallel to the x-axis or y-axis.
Takahashi will hold an exhibition of antique cars at a place on the xy-plane. In order to avoid damaging the half-broken cars too much, he will select the place of the exhibition so that the total distance covered will be minimized when all the cars are moved to the place. If such a place is not uniquely determined, among the places that satisfy the condition above, the place with the minimum x-coordinate will be selected. If the place is still not uniquely determined, among the places that satisfy the two conditions above, the place with the minimum y-coordinate will be selected.
Find the place of the exhibition that will be selected.
Constraints
* 2 \leq N \leq 4 × 10^4
* 1 \leq |A_i|,|B_i| \leq 10^4(1 \leq i \leq N)
* 0 \leq |C_i| \leq 10^4(1 \leq i \leq N)
* No two given lines are parallel.
* All input values are integers.
Inputs
Input is given from Standard Input in the following format:
N
A_1 B_1 C_1
:
A_N B_N C_N
Outputs
Print the x-coordinate and y-coordinate of the place of the exhibition that will be selected, in this order, with a space in between. The output will be judged as correct when the absolute or relative error is at most 10^{-9}.
Examples
Input
3
1 1 1
2 -1 2
-1 2 2
Output
1.000000000000000 1.000000000000000
Input
4
1 1 2
1 -1 0
3 -1 -2
1 -3 4
Output
-1.000000000000000 -1.000000000000000
Input
7
1 7 8
-2 4 9
3 -8 -5
9 2 -14
6 7 5
-8 -9 3
3 8 10
Output
-1.722222222222222 1.325000000000000 | instruction | 0 | 53,774 | 23 | 107,548 |
"Correct Solution:
```
def addbit(i):
i += 1
while i <= N:
BIT[i] += 1
i += i & (-i)
def getsum(i):
ret = 0
i += 1
while i != 0:
ret += BIT[i]
i -= i&(-i)
return ret
def bit(L):
global BIT
BIT=[0] * (N+1)
re = 0
for l in L:
re += getsum(l)
addbit(l)
return N*(N-1)//2 - re
def calc(Z):
Z.sort()
l, r, lc, rc = -1<<28, 1<<28, N*(N-1)//4+1, N*(N-1)//4+1
while (r - l) / max(abs(l), 1) > 0.000000001:
m = (l * rc + r * lc) / (lc + rc)
A = [a&((1<<16)-1) for a in sorted([(int((s*m+t)*2**40)<<16)+i for i, (s, t) in enumerate(Z)])]
c = bit(A)
if c > N*(N-1)//4:
l = m
lc = (c - N*(N-1)//4) * 2
else:
r = m
rc = (N*(N-1)//4 - c) * 2 + 1
return l
N = int(input())
X, Y = [], []
for _ in range(N):
a, b, c = map(int, input().split())
X.append((-a/b, c/b))
Y.append((-b/a, c/a))
print(calc(X), calc(Y))
``` | output | 1 | 53,774 | 23 | 107,549 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
There are N lines in the xy-plane. The i-th line is represented by A_ix+B_iy=C_i. Any two lines among the N+2 lines, the above N lines plus the x-axis and y-axis, cross each other at exactly one point.
For each pair 1 \leq i < j \leq N, there is a car at the cross point of the i-th and j-th lines. Even where three or more lines intersect at a point, a car is individually placed for each pair of lines. That is, there will be k(k-1)/2 cars placed at the intersection of k lines.
Those cars are already very old, and can only be moved parallel to the x-axis or y-axis.
Takahashi will hold an exhibition of antique cars at a place on the xy-plane. In order to avoid damaging the half-broken cars too much, he will select the place of the exhibition so that the total distance covered will be minimized when all the cars are moved to the place. If such a place is not uniquely determined, among the places that satisfy the condition above, the place with the minimum x-coordinate will be selected. If the place is still not uniquely determined, among the places that satisfy the two conditions above, the place with the minimum y-coordinate will be selected.
Find the place of the exhibition that will be selected.
Constraints
* 2 \leq N \leq 4 × 10^4
* 1 \leq |A_i|,|B_i| \leq 10^4(1 \leq i \leq N)
* 0 \leq |C_i| \leq 10^4(1 \leq i \leq N)
* No two given lines are parallel.
* All input values are integers.
Inputs
Input is given from Standard Input in the following format:
N
A_1 B_1 C_1
:
A_N B_N C_N
Outputs
Print the x-coordinate and y-coordinate of the place of the exhibition that will be selected, in this order, with a space in between. The output will be judged as correct when the absolute or relative error is at most 10^{-9}.
Examples
Input
3
1 1 1
2 -1 2
-1 2 2
Output
1.000000000000000 1.000000000000000
Input
4
1 1 2
1 -1 0
3 -1 -2
1 -3 4
Output
-1.000000000000000 -1.000000000000000
Input
7
1 7 8
-2 4 9
3 -8 -5
9 2 -14
6 7 5
-8 -9 3
3 8 10
Output
-1.722222222222222 1.325000000000000
Submitted Solution:
```
def addbit(i):
i += 1
while i <= N:
BIT[i] += 1
i += i & (-i)
def getsum(i):
ret = 0
i += 1
while i != 0:
ret += BIT[i]
i -= i&(-i)
return ret
def bit(L):
global BIT
BIT=[0] * (N+1)
re = 0
for l in L:
re += getsum(l)
addbit(l)
return N*(N-1)//2 - re
def calc(Z):
Z.sort()
l, r, lc, rc = -1<<28, 1<<28, N*(N-1)//4+1, N*(N-1)//4+1
while (r - l) / max(abs(l), 1) > 0.000000001:
m = (l * rc + r * lc) / (lc + rc)
A = [b for a, b in sorted([(s*m+t, i) for i, (s, t) in enumerate(Z)])]
c = bit(A)
if c > N*(N-1)//4:
l = m
lc = (c - N*(N-1)//4) * 2
else:
r = m
rc = (N*(N-1)//4 - c) * 2 + 1
return l
N = int(input())
X, Y = [], []
for _ in range(N):
a, b, c = map(int, input().split())
X.append((-a/b, c/b))
Y.append((-b/a, c/a))
print(calc(X), calc(Y))
``` | instruction | 0 | 53,775 | 23 | 107,550 |
Yes | output | 1 | 53,775 | 23 | 107,551 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
There are N lines in the xy-plane. The i-th line is represented by A_ix+B_iy=C_i. Any two lines among the N+2 lines, the above N lines plus the x-axis and y-axis, cross each other at exactly one point.
For each pair 1 \leq i < j \leq N, there is a car at the cross point of the i-th and j-th lines. Even where three or more lines intersect at a point, a car is individually placed for each pair of lines. That is, there will be k(k-1)/2 cars placed at the intersection of k lines.
Those cars are already very old, and can only be moved parallel to the x-axis or y-axis.
Takahashi will hold an exhibition of antique cars at a place on the xy-plane. In order to avoid damaging the half-broken cars too much, he will select the place of the exhibition so that the total distance covered will be minimized when all the cars are moved to the place. If such a place is not uniquely determined, among the places that satisfy the condition above, the place with the minimum x-coordinate will be selected. If the place is still not uniquely determined, among the places that satisfy the two conditions above, the place with the minimum y-coordinate will be selected.
Find the place of the exhibition that will be selected.
Constraints
* 2 \leq N \leq 4 × 10^4
* 1 \leq |A_i|,|B_i| \leq 10^4(1 \leq i \leq N)
* 0 \leq |C_i| \leq 10^4(1 \leq i \leq N)
* No two given lines are parallel.
* All input values are integers.
Inputs
Input is given from Standard Input in the following format:
N
A_1 B_1 C_1
:
A_N B_N C_N
Outputs
Print the x-coordinate and y-coordinate of the place of the exhibition that will be selected, in this order, with a space in between. The output will be judged as correct when the absolute or relative error is at most 10^{-9}.
Examples
Input
3
1 1 1
2 -1 2
-1 2 2
Output
1.000000000000000 1.000000000000000
Input
4
1 1 2
1 -1 0
3 -1 -2
1 -3 4
Output
-1.000000000000000 -1.000000000000000
Input
7
1 7 8
-2 4 9
3 -8 -5
9 2 -14
6 7 5
-8 -9 3
3 8 10
Output
-1.722222222222222 1.325000000000000
Submitted Solution:
```
def addbit(i):
i += 1
while i <= N:
BIT[i] += 1
i += i & (-i)
def getsum(i):
ret = 0
i += 1
while i != 0:
ret += BIT[i]
i -= i&(-i)
return ret
def bit(L):
global BIT
BIT=[0] * (N+1)
re = 0
for l in L:
re += getsum(l)
addbit(l)
return N*(N-1)//2 - re
def calc(Z):
Z.sort()
l, r, lc, rc = -1<<28, 1<<28, N*(N-1)//4+1, N*(N-1)//4+1
f = 1
while (r - l) / max(abs(l), 1) > 0.000000001:
m = (l+r) / 2 if f else (l * rc + r * lc) / (lc + rc)
A = [a&((1<<16)-1) for a in sorted([(int((s*m+t)*2**40)<<16)+i for i, (s, t) in enumerate(Z)])]
c = bit(A)
if c > N*(N-1)//4:
l = m
lc = (c - N*(N-1)//4) * 2
else:
r = m
rc = (N*(N-1)//4 - c) * 2 + 1
f ^= 1
return l
N = int(input())
X, Y = [], []
for _ in range(N):
a, b, c = map(int, input().split())
X.append((-a/b, c/b))
Y.append((-b/a, c/a))
print(calc(X), calc(Y))
``` | instruction | 0 | 53,776 | 23 | 107,552 |
Yes | output | 1 | 53,776 | 23 | 107,553 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
There are N lines in the xy-plane. The i-th line is represented by A_ix+B_iy=C_i. Any two lines among the N+2 lines, the above N lines plus the x-axis and y-axis, cross each other at exactly one point.
For each pair 1 \leq i < j \leq N, there is a car at the cross point of the i-th and j-th lines. Even where three or more lines intersect at a point, a car is individually placed for each pair of lines. That is, there will be k(k-1)/2 cars placed at the intersection of k lines.
Those cars are already very old, and can only be moved parallel to the x-axis or y-axis.
Takahashi will hold an exhibition of antique cars at a place on the xy-plane. In order to avoid damaging the half-broken cars too much, he will select the place of the exhibition so that the total distance covered will be minimized when all the cars are moved to the place. If such a place is not uniquely determined, among the places that satisfy the condition above, the place with the minimum x-coordinate will be selected. If the place is still not uniquely determined, among the places that satisfy the two conditions above, the place with the minimum y-coordinate will be selected.
Find the place of the exhibition that will be selected.
Constraints
* 2 \leq N \leq 4 × 10^4
* 1 \leq |A_i|,|B_i| \leq 10^4(1 \leq i \leq N)
* 0 \leq |C_i| \leq 10^4(1 \leq i \leq N)
* No two given lines are parallel.
* All input values are integers.
Inputs
Input is given from Standard Input in the following format:
N
A_1 B_1 C_1
:
A_N B_N C_N
Outputs
Print the x-coordinate and y-coordinate of the place of the exhibition that will be selected, in this order, with a space in between. The output will be judged as correct when the absolute or relative error is at most 10^{-9}.
Examples
Input
3
1 1 1
2 -1 2
-1 2 2
Output
1.000000000000000 1.000000000000000
Input
4
1 1 2
1 -1 0
3 -1 -2
1 -3 4
Output
-1.000000000000000 -1.000000000000000
Input
7
1 7 8
-2 4 9
3 -8 -5
9 2 -14
6 7 5
-8 -9 3
3 8 10
Output
-1.722222222222222 1.325000000000000
Submitted Solution:
```
def addbit(i):
i += 1
while i <= N:
BIT[i] += 1
i += i & (-i)
def getsum(i):
ret = 0
i += 1
while i != 0:
ret += BIT[i]
i -= i&(-i)
return ret
def bit(L):
global BIT
BIT=[0] * (N+1)
re = 0
for l in L:
re += getsum(l)
addbit(l)
return N*(N-1)//2 - re
def get_rank(L):
D = {x:i for i,x in enumerate(sorted(L))}
return [D[x] for x in L]
def calc(Z):
Z.sort()
l, r, lc, rc = -1<<28, 1<<28, N*(N-1)//4+1, N*(N-1)//4+1
while (r - l) / max(abs(l), 1) > 0.000000001:
m = (l * rc + r * lc) / (lc + rc)
A = [b for a, b in sorted([(s*m+t, i) for i, (s, t) in enumerate(Z)])]
A = get_rank([s*m+t for s, t in Z])
c = bit(A)
if c > N*(N-1)//4:
l = m
lc = (c - N*(N-1)//4) * 2
else:
r = m
rc = (N*(N-1)//4 - c) * 2 + 1
return l
N = int(input())
X, Y = [], []
for _ in range(N):
a, b, c = map(int, input().split())
X.append((-a/b, c/b))
Y.append((-b/a, c/a))
print(calc(X), calc(Y))
``` | instruction | 0 | 53,777 | 23 | 107,554 |
Yes | output | 1 | 53,777 | 23 | 107,555 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
There are N lines in the xy-plane. The i-th line is represented by A_ix+B_iy=C_i. Any two lines among the N+2 lines, the above N lines plus the x-axis and y-axis, cross each other at exactly one point.
For each pair 1 \leq i < j \leq N, there is a car at the cross point of the i-th and j-th lines. Even where three or more lines intersect at a point, a car is individually placed for each pair of lines. That is, there will be k(k-1)/2 cars placed at the intersection of k lines.
Those cars are already very old, and can only be moved parallel to the x-axis or y-axis.
Takahashi will hold an exhibition of antique cars at a place on the xy-plane. In order to avoid damaging the half-broken cars too much, he will select the place of the exhibition so that the total distance covered will be minimized when all the cars are moved to the place. If such a place is not uniquely determined, among the places that satisfy the condition above, the place with the minimum x-coordinate will be selected. If the place is still not uniquely determined, among the places that satisfy the two conditions above, the place with the minimum y-coordinate will be selected.
Find the place of the exhibition that will be selected.
Constraints
* 2 \leq N \leq 4 × 10^4
* 1 \leq |A_i|,|B_i| \leq 10^4(1 \leq i \leq N)
* 0 \leq |C_i| \leq 10^4(1 \leq i \leq N)
* No two given lines are parallel.
* All input values are integers.
Inputs
Input is given from Standard Input in the following format:
N
A_1 B_1 C_1
:
A_N B_N C_N
Outputs
Print the x-coordinate and y-coordinate of the place of the exhibition that will be selected, in this order, with a space in between. The output will be judged as correct when the absolute or relative error is at most 10^{-9}.
Examples
Input
3
1 1 1
2 -1 2
-1 2 2
Output
1.000000000000000 1.000000000000000
Input
4
1 1 2
1 -1 0
3 -1 -2
1 -3 4
Output
-1.000000000000000 -1.000000000000000
Input
7
1 7 8
-2 4 9
3 -8 -5
9 2 -14
6 7 5
-8 -9 3
3 8 10
Output
-1.722222222222222 1.325000000000000
Submitted Solution:
```
from collections import defaultdict, deque, Counter
from heapq import heappush, heappop, heapify
from itertools import permutations, accumulate, combinations, combinations_with_replacement
from math import sqrt, ceil, floor, factorial
from bisect import bisect_left, bisect_right, insort_left, insort_right
from copy import deepcopy
from operator import itemgetter
from functools import reduce, lru_cache # @lru_cache(None)
from fractions import gcd
import sys
def input(): return sys.stdin.readline().rstrip()
def I(): return int(input())
def Is(): return (int(x) for x in input().split())
def LI(): return list(Is())
def TI(): return tuple(Is())
def IR(n): return [I() for _ in range(n)]
def LIR(n): return [LI() for _ in range(n)]
def TIR(n): return [TI() for _ in range(n)]
def S(): return input()
def Ss(): return input().split()
def LS(): return list(S())
def SR(n): return [S() for _ in range(n)]
def SsR(n): return [Ss() for _ in range(n)]
def LSR(n): return [LS() for _ in range(n)]
sys.setrecursionlimit(10**6)
MOD = 10**9+7
INF = 10**18
EPS = 1e-9
# ----------------------------------------------------------- #
class BinaryIndexedTree:
def __init__(self, n):
self.size = n
self.tree = [0] * (n + 1)
def sum(self, i): # 1-index
s = 0
while i > 0:
s += self.tree[i]
i -= i & -i
return s
def add(self, i, x): # 1-index
while i <= self.size:
self.tree[i] += x
i += i & -i
"""
# 使用例
bit = BinaryIndexedTree(10) # 要素数を与えてインスタンス化
bit.add(2, 10) # a2に10を加える
bit.add(3, -6) # a3に-6を加える
print(bit.sum(6)) # a1～a6の合計を返す
print(bit.sum(6) - bit.sum(3)) # a4～a6の合計を返す
"""
def compress(A):
dic = {element: i for i, element in enumerate(sorted(set(A)), start=1)}
return [dic[a] for a in A]
def meguru_bisect(ng, ok, check):
"""
初期値のng,okを受け取り, check=>Trueを満たす最大値(最小値)を返す
条件を満たす最大値を求める場合、初期値は(ng:上限の外, ok:下限の外) 例) 10**9+1, -1
条件を満たす最小値を求める場合、初期値は(ng:下限の外, ok:上限の外) 例) -1, 10**9+1
上限の外や下限の外が返ってくる場合は条件を満たす値が範囲内になかったことを示すので、例外処理が必要
"""
# while abs(ok - ng) > 1:
for _ in range(80):
if abs(ok - ng) < EPS:
break
# mid = (ok + ng) // 2
mid = (ok + ng) / 2
if check(mid):
ok = mid
else:
ng = mid
return ok
def check_x(num):
bit = BinaryIndexedTree(n)
inversion_num = 0
X = compress([(c-b*num)/a for a, b, c in X_ABC])
for i, x in enumerate(X, start=1):
bit.add(x, 1)
inversion_num += i - bit.sum(x)
return inversion_num >= m
def check_y(num):
bit = BinaryIndexedTree(n)
inversion_num = 0
Y = compress([(c-a*num)/b for a, b, c in Y_ABC])
for i, y in enumerate(Y, start=1):
bit.add(y, 1)
inversion_num += i - bit.sum(y)
return inversion_num >= m
n = I()
ABC = TIR(n)
m = (n*(n-1)//2+1)//2
X_ABC = sorted(ABC, key=lambda abc: abc[1]/abc[0]) # 傾きb/aの昇順
Y_ABC = sorted(ABC, key=lambda abc: abc[0]/abc[1]) # 傾きa/bの昇順
mid_x = meguru_bisect(-10**9, 10**9, check_x)
mid_y = meguru_bisect(-10**9, 10**9, check_y)
print(mid_y, mid_x) # ????
``` | instruction | 0 | 53,778 | 23 | 107,556 |
Yes | output | 1 | 53,778 | 23 | 107,557 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
There are N lines in the xy-plane. The i-th line is represented by A_ix+B_iy=C_i. Any two lines among the N+2 lines, the above N lines plus the x-axis and y-axis, cross each other at exactly one point.
For each pair 1 \leq i < j \leq N, there is a car at the cross point of the i-th and j-th lines. Even where three or more lines intersect at a point, a car is individually placed for each pair of lines. That is, there will be k(k-1)/2 cars placed at the intersection of k lines.
Those cars are already very old, and can only be moved parallel to the x-axis or y-axis.
Takahashi will hold an exhibition of antique cars at a place on the xy-plane. In order to avoid damaging the half-broken cars too much, he will select the place of the exhibition so that the total distance covered will be minimized when all the cars are moved to the place. If such a place is not uniquely determined, among the places that satisfy the condition above, the place with the minimum x-coordinate will be selected. If the place is still not uniquely determined, among the places that satisfy the two conditions above, the place with the minimum y-coordinate will be selected.
Find the place of the exhibition that will be selected.
Constraints
* 2 \leq N \leq 4 × 10^4
* 1 \leq |A_i|,|B_i| \leq 10^4(1 \leq i \leq N)
* 0 \leq |C_i| \leq 10^4(1 \leq i \leq N)
* No two given lines are parallel.
* All input values are integers.
Inputs
Input is given from Standard Input in the following format:
N
A_1 B_1 C_1
:
A_N B_N C_N
Outputs
Print the x-coordinate and y-coordinate of the place of the exhibition that will be selected, in this order, with a space in between. The output will be judged as correct when the absolute or relative error is at most 10^{-9}.
Examples
Input
3
1 1 1
2 -1 2
-1 2 2
Output
1.000000000000000 1.000000000000000
Input
4
1 1 2
1 -1 0
3 -1 -2
1 -3 4
Output
-1.000000000000000 -1.000000000000000
Input
7
1 7 8
-2 4 9
3 -8 -5
9 2 -14
6 7 5
-8 -9 3
3 8 10
Output
-1.722222222222222 1.325000000000000
Submitted Solution:
```
from collections import defaultdict, deque, Counter
from heapq import heappush, heappop, heapify
from itertools import permutations, accumulate, combinations, combinations_with_replacement
from math import sqrt, ceil, floor, factorial
from bisect import bisect_left, bisect_right, insort_left, insort_right
from copy import deepcopy
from operator import itemgetter
from functools import reduce, lru_cache # @lru_cache(None)
from fractions import gcd
import sys
def input(): return sys.stdin.readline().rstrip()
def I(): return int(input())
def Is(): return (int(x) for x in input().split())
def LI(): return list(Is())
def TI(): return tuple(Is())
def IR(n): return [I() for _ in range(n)]
def LIR(n): return [LI() for _ in range(n)]
def TIR(n): return [TI() for _ in range(n)]
def S(): return input()
def Ss(): return input().split()
def LS(): return list(S())
def SR(n): return [S() for _ in range(n)]
def SsR(n): return [Ss() for _ in range(n)]
def LSR(n): return [LS() for _ in range(n)]
sys.setrecursionlimit(10**6)
MOD = 10**9+7
INF = 10**18
EPS = 1e-10
# ----------------------------------------------------------- #
class BinaryIndexedTree:
def __init__(self, n):
self.size = n
self.tree = [0] * (n + 1)
def sum(self, i): # 1-index
s = 0
while i > 0:
s += self.tree[i]
i -= i & -i
return s
def add(self, i, x): # 1-index
while i <= self.size:
self.tree[i] += x
i += i & -i
"""
# 使用例
bit = BinaryIndexedTree(10) # 要素数を与えてインスタンス化
bit.add(2, 10) # a2に10を加える
bit.add(3, -6) # a3に-6を加える
print(bit.sum(6)) # a1～a6の合計を返す
print(bit.sum(6) - bit.sum(3)) # a4～a6の合計を返す
"""
def compress(A):
dic = {element: i for i, element in enumerate(sorted(set(A)), start=1)}
return [dic[a] for a in A]
def meguru_bisect(ng, ok, check):
"""
初期値のng,okを受け取り, check=>Trueを満たす最大値(最小値)を返す
条件を満たす最大値を求める場合、初期値は(ng:上限の外, ok:下限の外) 例) 10**9+1, -1
条件を満たす最小値を求める場合、初期値は(ng:下限の外, ok:上限の外) 例) -1, 10**9+1
上限の外や下限の外が返ってくる場合は条件を満たす値が範囲内になかったことを示すので、例外処理が必要
"""
# while abs(ok - ng) > 1:
while abs(ok - ng) > EPS:
# mid = (ok + ng) // 2
mid = (ok + ng) / 2
if check(mid):
ok = mid
else:
ng = mid
return ok
def check_x(num):
bit = BinaryIndexedTree(n)
inversion_num = 0
X = compress([(c-b*num)/a for a, b, c in X_ABC])
for i, x in enumerate(X, start=1):
bit.add(x, 1)
inversion_num += i - bit.sum(x)
return inversion_num >= m
def check_y(num):
bit = BinaryIndexedTree(n)
inversion_num = 0
Y = compress([(c-a*num)/b for a, b, c in Y_ABC])
for i, y in enumerate(Y, start=1):
bit.add(y, 1)
inversion_num += i - bit.sum(y)
return inversion_num >= m
n = I()
ABC = TIR(n)
m = (n*(n-1)//2+1)//2
X_ABC = sorted(ABC, key=lambda abc: abc[1]/abc[0]) # 傾きb/aの昇順
Y_ABC = sorted(ABC, key=lambda abc: abc[0]/abc[1]) # 傾きa/bの昇順
mid_x = meguru_bisect(-10**9, 10**9, check_x)
mid_y = meguru_bisect(-10**9, 10**9, check_y)
print(mid_y, mid_x) # ????
``` | instruction | 0 | 53,779 | 23 | 107,558 |
No | output | 1 | 53,779 | 23 | 107,559 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
There are N lines in the xy-plane. The i-th line is represented by A_ix+B_iy=C_i. Any two lines among the N+2 lines, the above N lines plus the x-axis and y-axis, cross each other at exactly one point.
For each pair 1 \leq i < j \leq N, there is a car at the cross point of the i-th and j-th lines. Even where three or more lines intersect at a point, a car is individually placed for each pair of lines. That is, there will be k(k-1)/2 cars placed at the intersection of k lines.
Those cars are already very old, and can only be moved parallel to the x-axis or y-axis.
Takahashi will hold an exhibition of antique cars at a place on the xy-plane. In order to avoid damaging the half-broken cars too much, he will select the place of the exhibition so that the total distance covered will be minimized when all the cars are moved to the place. If such a place is not uniquely determined, among the places that satisfy the condition above, the place with the minimum x-coordinate will be selected. If the place is still not uniquely determined, among the places that satisfy the two conditions above, the place with the minimum y-coordinate will be selected.
Find the place of the exhibition that will be selected.
Constraints
* 2 \leq N \leq 4 × 10^4
* 1 \leq |A_i|,|B_i| \leq 10^4(1 \leq i \leq N)
* 0 \leq |C_i| \leq 10^4(1 \leq i \leq N)
* No two given lines are parallel.
* All input values are integers.
Inputs
Input is given from Standard Input in the following format:
N
A_1 B_1 C_1
:
A_N B_N C_N
Outputs
Print the x-coordinate and y-coordinate of the place of the exhibition that will be selected, in this order, with a space in between. The output will be judged as correct when the absolute or relative error is at most 10^{-9}.
Examples
Input
3
1 1 1
2 -1 2
-1 2 2
Output
1.000000000000000 1.000000000000000
Input
4
1 1 2
1 -1 0
3 -1 -2
1 -3 4
Output
-1.000000000000000 -1.000000000000000
Input
7
1 7 8
-2 4 9
3 -8 -5
9 2 -14
6 7 5
-8 -9 3
3 8 10
Output
-1.722222222222222 1.325000000000000
Submitted Solution:
```
class BIT():
def __init__(self,n):
self.BIT=[0]*(n+1)
self.num=n
def query(self,idx):
res_sum = 0
while idx > 0:
res_sum += self.BIT[idx]
idx -= idx&(-idx)
return res_sum
#Ai += x O(logN)
def update(self,idx,x):
while idx <= self.num:
self.BIT[idx] += x
idx += idx&(-idx)
return
def comp(L):
S=list(set(L))
S.sort()
return {i:e for e,i in enumerate(S)}
import sys,random
input=sys.stdin.readline
N=int(input())
A=[0]*N;B=[0]*N;C=[0]*N
for i in range(N):
A[i],B[i],C[i]=map(int,input().split())
line=[(A[i]/B[i],i) for i in range(N)]
line.sort()
line=[line[i][1] for i in range(N)]
line2=[(B[i]/A[i],i) for i in range(N)]
line2.sort()
line2=[line2[i][1] for i in range(N)]
def cond(n):
tempC=[C[i]-n*A[i] for i in range(N)]
data=[tempC[i]/B[i] for i in range(N)]
data=comp(data)
bit=BIT(len(data))
res=0
for i in range(N):
id2=data[tempC[line[i]]/B[line[i]]]
res+=i-bit.query(id2)
bit.update(id2+1,1)
num=N*(N-1)//2
return res>=(num+1)//2
def cond2(n):
tempC=[C[i]-n*B[i] for i in range(N)]
data=[tempC[i]/A[i] for i in range(N)]
data=comp(data)
bit=BIT(len(data))
res=0
for i in range(N):
id2=data[tempC[line2[i]]/A[line2[i]]]
res+=i-bit.query(id2)
bit.update(id2+1,1)
num=N*(N-1)//2
return res>=(num+1)//2
start=-10**8
end=10**8
count=0
while end-start>10**-9:
count+=1
test=(end+start)/2
if cond(test):
end=test
else:
start=test
start2=-10**8
end2=10**8
while end2-start2>10**-9:
test=(end2+start2)/2
count+=1
if cond2(test):
end2=test
else:
start2=test
print(end,end2)
#print(count)
``` | instruction | 0 | 53,780 | 23 | 107,560 |
No | output | 1 | 53,780 | 23 | 107,561 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
There are N lines in the xy-plane. The i-th line is represented by A_ix+B_iy=C_i. Any two lines among the N+2 lines, the above N lines plus the x-axis and y-axis, cross each other at exactly one point.
For each pair 1 \leq i < j \leq N, there is a car at the cross point of the i-th and j-th lines. Even where three or more lines intersect at a point, a car is individually placed for each pair of lines. That is, there will be k(k-1)/2 cars placed at the intersection of k lines.
Those cars are already very old, and can only be moved parallel to the x-axis or y-axis.
Takahashi will hold an exhibition of antique cars at a place on the xy-plane. In order to avoid damaging the half-broken cars too much, he will select the place of the exhibition so that the total distance covered will be minimized when all the cars are moved to the place. If such a place is not uniquely determined, among the places that satisfy the condition above, the place with the minimum x-coordinate will be selected. If the place is still not uniquely determined, among the places that satisfy the two conditions above, the place with the minimum y-coordinate will be selected.
Find the place of the exhibition that will be selected.
Constraints
* 2 \leq N \leq 4 × 10^4
* 1 \leq |A_i|,|B_i| \leq 10^4(1 \leq i \leq N)
* 0 \leq |C_i| \leq 10^4(1 \leq i \leq N)
* No two given lines are parallel.
* All input values are integers.
Inputs
Input is given from Standard Input in the following format:
N
A_1 B_1 C_1
:
A_N B_N C_N
Outputs
Print the x-coordinate and y-coordinate of the place of the exhibition that will be selected, in this order, with a space in between. The output will be judged as correct when the absolute or relative error is at most 10^{-9}.
Examples
Input
3
1 1 1
2 -1 2
-1 2 2
Output
1.000000000000000 1.000000000000000
Input
4
1 1 2
1 -1 0
3 -1 -2
1 -3 4
Output
-1.000000000000000 -1.000000000000000
Input
7
1 7 8
-2 4 9
3 -8 -5
9 2 -14
6 7 5
-8 -9 3
3 8 10
Output
-1.722222222222222 1.325000000000000
Submitted Solution:
```
# coding: utf-8
import math
import fractions
import heapq
import collections
import re
import array
import bisect
import itertools
from collections import Counter, defaultdict
def argsort(l, one_base=False):
return sorted(range(one_base, len(l) + one_base), key=lambda i: l[i-one_base])
class BinaryIndexedTree(object):
def __init__(self, N):
self.N = N
self.tree = [0] * (N + 1)
def add(self, a, w):
x = a
while x <= self.N:
self.tree[x] += w
x += (x & -x)
def sum(self, a):
if a == 0:
return 0
s = 0
x = a
while x > 0:
s += self.tree[x]
x -= (x & -x)
return s
def count_inv(A):
bit = BinaryIndexedTree(100001)
ans = 0
for j in range(len(A)):
ans += j - bit.sum(A[j])
bit.add(A[j], 1)
return ans
def count_crossed_lines(N, C, a, b, x):
c = 2
Y = [(-C[i][a] * x + C[i][c]) / C[i][b] for i in range(N)]
yl = argsort(Y, one_base=True)
c = count_inv(yl)
return c
def find_coord(N, C, a, b):
med_v = math.ceil(N * (N-1) / 4)
iangles = [C[i][a] / C[i][b] for i in range(N)]
coefs = [C[i] for i in argsort(iangles)]
# bin-search
INF = 1e9
rg = [-INF, INF]
d = rg[1] - rg[0]
m = (rg[1] + rg[0]) / 2
while d > 1e-9:
m = (rg[1] + rg[0]) / 2
cl = count_crossed_lines(N, coefs, a, b, m)
if cl < med_v:
rg[0] = m
else:
rg[1] = m
d = rg[1] - rg[0]
return m
def main():
N = int(input())
coefs = [None] * N
for i in range(N):
a, b, c = map(int, input().split(" "))
coefs[i] = (a, b, c)
x = find_coord(N, coefs, 0, 1)
y = find_coord(N, coefs, 1, 0)
print("{} {}".format(x, y))
if __name__ == "__main__":
main()
``` | instruction | 0 | 53,781 | 23 | 107,562 |
No | output | 1 | 53,781 | 23 | 107,563 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
There are N lines in the xy-plane. The i-th line is represented by A_ix+B_iy=C_i. Any two lines among the N+2 lines, the above N lines plus the x-axis and y-axis, cross each other at exactly one point.
For each pair 1 \leq i < j \leq N, there is a car at the cross point of the i-th and j-th lines. Even where three or more lines intersect at a point, a car is individually placed for each pair of lines. That is, there will be k(k-1)/2 cars placed at the intersection of k lines.
Those cars are already very old, and can only be moved parallel to the x-axis or y-axis.
Takahashi will hold an exhibition of antique cars at a place on the xy-plane. In order to avoid damaging the half-broken cars too much, he will select the place of the exhibition so that the total distance covered will be minimized when all the cars are moved to the place. If such a place is not uniquely determined, among the places that satisfy the condition above, the place with the minimum x-coordinate will be selected. If the place is still not uniquely determined, among the places that satisfy the two conditions above, the place with the minimum y-coordinate will be selected.
Find the place of the exhibition that will be selected.
Constraints
* 2 \leq N \leq 4 × 10^4
* 1 \leq |A_i|,|B_i| \leq 10^4(1 \leq i \leq N)
* 0 \leq |C_i| \leq 10^4(1 \leq i \leq N)
* No two given lines are parallel.
* All input values are integers.
Inputs
Input is given from Standard Input in the following format:
N
A_1 B_1 C_1
:
A_N B_N C_N
Outputs
Print the x-coordinate and y-coordinate of the place of the exhibition that will be selected, in this order, with a space in between. The output will be judged as correct when the absolute or relative error is at most 10^{-9}.
Examples
Input
3
1 1 1
2 -1 2
-1 2 2
Output
1.000000000000000 1.000000000000000
Input
4
1 1 2
1 -1 0
3 -1 -2
1 -3 4
Output
-1.000000000000000 -1.000000000000000
Input
7
1 7 8
-2 4 9
3 -8 -5
9 2 -14
6 7 5
-8 -9 3
3 8 10
Output
-1.722222222222222 1.325000000000000
Submitted Solution:
```
import sys
readline = sys.stdin.readline
class BIT:
#1-indexed
def __init__(self, n):
self.size = n
self.tree = [0] * (n + 1)
self.p = 2**(n.bit_length() - 1)
self.dep = n.bit_length()
def get(self, i):
s = 0
while i > 0:
s += self.tree[i]
i -= i & -i
return s
def add(self, i, x):
while i <= self.size:
self.tree[i] += x
i += i & -i
def bl(self, v):
if v <= 0:
return -1
s = 0
k = self.p
for _ in range(self.dep):
if s + k <= self.size and self.tree[s+k] < v:
s += k
v -= self.tree[s+k]
k //= 2
return s + 1
def reset(self):
self.tree = [0]*(self.size+1)
N = int(readline())
INF = 1e9
EPS = 1e-9
Points = [tuple(map(int, readline().split())) for _ in range(N)]
XA = [-a/b for a, b, _ in Points]
XB = [c/b for _, b, c in Points]
YA = [-b/a for a, b, _ in Points]
YB = [c/a for a, _, c in Points]
con = -(-N*(N-1)//4)
T = BIT(N)
ds = sorted(range(N), key = lambda x: XA[x])
rd = [None]*N
for i in range(N):
rd[ds[i]] = i
ng = -INF
ok = INF
while abs(ok-ng)/max(1, min(abs(ok), abs(ng))) > EPS:
med = (ok+ng)/2
T.reset()
res = 0
for idx in sorted(range(N), key = lambda x: XA[x]*med + XB[x]):
res += T.get(rd[idx]+1)
T.add(rd[idx]+1, 1)
if res >= con:
ok = med
else:
ng = med
X = ok
ds = sorted(range(N), key = lambda x: YA[x])
rd = [None]*N
for i in range(N):
rd[ds[i]] = i
ng = -INF
ok = INF
while abs(ok-ng)/max(1, min(abs(ok), abs(ng))) > EPS:
med = (ok+ng)/2
T.reset()
res = 0
for idx in sorted(range(N), key = lambda x: YA[x]*med + YB[x]):
res += T.get(rd[idx]+1)
T.add(rd[idx]+1, 1)
if res >= con:
ok = med
else:
ng = med
Y = ok
print(X, Y)
``` | instruction | 0 | 53,782 | 23 | 107,564 |
No | output | 1 | 53,782 | 23 | 107,565 |
Provide a correct Python 3 solution for this coding contest problem.
I decided to create a program that displays a "round and round pattern". The "round and round pattern" is as follows.
* If the length of one side is n, it is displayed as a character string with n rows and n columns.
* A spiral pattern that rotates clockwise with the lower left corner as the base point.
* The part with a line is represented by # (half-width sharp), and the blank part is represented by "" (half-width blank).
* Leave a space between the lines.
Create a program that takes an integer n as an input and outputs a "round and round pattern" with a side length of n.
Input
The input is given in the following format:
d
n1
n2
::
nd
The number of datasets d (d ≤ 20) is given to the first line, and the side length ni (1 ≤ ni ≤ 100) of the i-th round pattern is given to each of the following d lines.
Output
Please output a round and round pattern for each data set. Insert a blank line between the datasets.
Example
Input
2
5
6
Output
#####
# #
# # #
# # #
# ###
######
# #
# ## #
# # #
# # #
# #### | instruction | 0 | 53,821 | 23 | 107,642 |
"Correct Solution:
```
vector = ((0, -1), (1, 0), (0, 1), (-1, 0))
def make_guruguru(d):
lst = [["#"] * (d + 4)]
for _ in range(d + 2):
lst.append(["#"] + [" "] * (d + 2) + ["#"])
lst.append(["#"] * (d + 4))
x, y = 2, d + 1
lst[y][x] = "#"
direct = 0
vx, vy = vector[0]
cnt = 1
while True:
while lst[y + vy * 2][x + vx * 2] == " ":
lst[y + vy][x + vx] = "#"
y += vy
x += vx
cnt += 1
if cnt <= 1:
break
direct = (direct + 1) % 4
vx, vy = vector[direct]
cnt = 0
for y in range(2, d + 2):
print("".join(lst[y][2:-2]))
n = int(input())
make_guruguru(int(input()))
for _ in range(n - 1):
print()
make_guruguru(int(input()))
``` | output | 1 | 53,821 | 23 | 107,643 |
Provide a correct Python 3 solution for this coding contest problem.
I decided to create a program that displays a "round and round pattern". The "round and round pattern" is as follows.
* If the length of one side is n, it is displayed as a character string with n rows and n columns.
* A spiral pattern that rotates clockwise with the lower left corner as the base point.
* The part with a line is represented by # (half-width sharp), and the blank part is represented by "" (half-width blank).
* Leave a space between the lines.
Create a program that takes an integer n as an input and outputs a "round and round pattern" with a side length of n.
Input
The input is given in the following format:
d
n1
n2
::
nd
The number of datasets d (d ≤ 20) is given to the first line, and the side length ni (1 ≤ ni ≤ 100) of the i-th round pattern is given to each of the following d lines.
Output
Please output a round and round pattern for each data set. Insert a blank line between the datasets.
Example
Input
2
5
6
Output
#####
# #
# # #
# # #
# ###
######
# #
# ## #
# # #
# # #
# #### | instruction | 0 | 53,822 | 23 | 107,644 |
"Correct Solution:
```
# -*- coding: utf-8 -*-
"""
http://judge.u-aizu.ac.jp/onlinejudge/description.jsp?id=0141
"""
import sys
from sys import stdin
input = stdin.readline
from itertools import cycle
def guruguru(n):
dirs = cycle([(0, -1), (1, 0), (0, 1), (-1, 0)]) # x, y???????????? (???????????????????????????)
M = [[' '] * n for _ in range(n)] # ??????????????¨?????????????????§?????????
cx = 0 # ??????????????°???
cy = n - 1
line = 0 # ???????????§??????????????????n??¨???????????°??????????????¨??????
while line < n:
line += 1
dx, dy = dirs.__next__() # ???????????????????????????????????????????????????
while True:
M[cy][cx] = '#'
nx = cx + dx # ?¬???????????????¨???????????????
ny = cy + dy
nnx = nx + dx # ?¬?????¬???????????????¨???????????????
nny = ny + dy
if nx < 0 or nx >= n: # ??????????????????????????????????????§???????????¢?????????
break
if ny < 0 or ny >= n:
break
if nny < 0 or nny >= n or nnx < 0 or nnx >= n:
pass
else:
if M[nny][nnx] != ' ': # ??????????????????????????????????????¢??????????????????????????£??????????????´??????????????¢?????????
break
cx = nx
cy = ny
# ?????????????????????????????????
for l in M:
print(''.join(l))
def main(args):
n = int(input())
for i in range(n):
size = int(input())
guruguru(size)
if i != (n - 1): # ????????\?????????????????????????????????????????\??????
print()
if __name__ == '__main__':
main(sys.argv[1:])
``` | output | 1 | 53,822 | 23 | 107,645 |
Provide a correct Python 3 solution for this coding contest problem.
I decided to create a program that displays a "round and round pattern". The "round and round pattern" is as follows.
* If the length of one side is n, it is displayed as a character string with n rows and n columns.
* A spiral pattern that rotates clockwise with the lower left corner as the base point.
* The part with a line is represented by # (half-width sharp), and the blank part is represented by "" (half-width blank).
* Leave a space between the lines.
Create a program that takes an integer n as an input and outputs a "round and round pattern" with a side length of n.
Input
The input is given in the following format:
d
n1
n2
::
nd
The number of datasets d (d ≤ 20) is given to the first line, and the side length ni (1 ≤ ni ≤ 100) of the i-th round pattern is given to each of the following d lines.
Output
Please output a round and round pattern for each data set. Insert a blank line between the datasets.
Example
Input
2
5
6
Output
#####
# #
# # #
# # #
# ###
######
# #
# ## #
# # #
# # #
# #### | instruction | 0 | 53,823 | 23 | 107,646 |
"Correct Solution:
```
# -*- coding: utf-8 -*-
"""
http://judge.u-aizu.ac.jp/onlinejudge/description.jsp?id=0141
"""
import sys
from sys import stdin
input = stdin.readline
from itertools import cycle
def guruguru(n):
dirs = cycle([(0, -1), (1, 0), (0, 1), (-1, 0)]) # x, y???????????? (???????????????????????????)
M = [[' '] * n for _ in range(n)] # ??????????????¨?????????????????§?????????
cx = 0 # ??????????????°???
cy = n - 1
line = 0 # ???????????§??????????????????n??¨???????????°??????????????¨??????
while line < n:
line += 1
dx, dy = dirs.__next__() # ???????????????????????????????????????????????????
while True:
M[cy][cx] = '#'
nx = cx + dx # ?¬???????????????¨???????????????
ny = cy + dy
if not 0 <= nx < n: # ??????????????????????????????????????§???????????¢?????????
break
if not 0 <= ny < n:
break
nnx = nx + dx # ?¬?????¬???????????????¨???????????????
nny = ny + dy
if 0 <= nny < n and 0 <= nnx < n:
if M[nny][nnx] != ' ': # ??????????????????????????????????????¢??????????????????????????£??????????????´??????????????¢?????????
break
cx = nx
cy = ny
# ?????????????????????????????????
for l in M:
print(''.join(l))
def main(args):
n = int(input())
for i in range(n):
size = int(input())
guruguru(size)
if i != (n - 1): # ????????\?????????????????????????????????????????\??????
print()
if __name__ == '__main__':
main(sys.argv[1:])
``` | output | 1 | 53,823 | 23 | 107,647 |
Provide a correct Python 3 solution for this coding contest problem.
I decided to create a program that displays a "round and round pattern". The "round and round pattern" is as follows.
* If the length of one side is n, it is displayed as a character string with n rows and n columns.
* A spiral pattern that rotates clockwise with the lower left corner as the base point.
* The part with a line is represented by # (half-width sharp), and the blank part is represented by "" (half-width blank).
* Leave a space between the lines.
Create a program that takes an integer n as an input and outputs a "round and round pattern" with a side length of n.
Input
The input is given in the following format:
d
n1
n2
::
nd
The number of datasets d (d ≤ 20) is given to the first line, and the side length ni (1 ≤ ni ≤ 100) of the i-th round pattern is given to each of the following d lines.
Output
Please output a round and round pattern for each data set. Insert a blank line between the datasets.
Example
Input
2
5
6
Output
#####
# #
# # #
# # #
# ###
######
# #
# ## #
# # #
# # #
# #### | instruction | 0 | 53,824 | 23 | 107,648 |
"Correct Solution:
```
def p(t):
for r in t:
for c in r:
print(c,end="")
print("")
a = int(input())
for j in range(a):
n = int(input())
t = [ [ " " for _ in range(n) ] for _ in range(n)]
d = 1 # 0:up, 1:right, 2:down, 3:left
for i in range(n):
t[i][0] = "#"
x = 0
y = 0
for m in range(n-1):
l = n - 1 - (m//2)*2
for i in range(l):
if d == 0:
y -= 1
elif d == 1:
x += 1
elif d == 2:
y += 1
elif d == 3:
x -= 1
t[y][x] = "#"
d = (d + 1) % 4
p(t)
if j != a-1:
print("")
``` | output | 1 | 53,824 | 23 | 107,649 |
Provide a correct Python 3 solution for this coding contest problem.
I decided to create a program that displays a "round and round pattern". The "round and round pattern" is as follows.
* If the length of one side is n, it is displayed as a character string with n rows and n columns.
* A spiral pattern that rotates clockwise with the lower left corner as the base point.
* The part with a line is represented by # (half-width sharp), and the blank part is represented by "" (half-width blank).
* Leave a space between the lines.
Create a program that takes an integer n as an input and outputs a "round and round pattern" with a side length of n.
Input
The input is given in the following format:
d
n1
n2
::
nd
The number of datasets d (d ≤ 20) is given to the first line, and the side length ni (1 ≤ ni ≤ 100) of the i-th round pattern is given to each of the following d lines.
Output
Please output a round and round pattern for each data set. Insert a blank line between the datasets.
Example
Input
2
5
6
Output
#####
# #
# # #
# # #
# ###
######
# #
# ## #
# # #
# # #
# #### | instruction | 0 | 53,825 | 23 | 107,650 |
"Correct Solution:
```
# -*- coding: utf-8 -*-
"""
http://judge.u-aizu.ac.jp/onlinejudge/description.jsp?id=0141
"""
import sys
from sys import stdin
input = stdin.readline
M = []
def guruguru(n):
global M
dirs = [(0, -1), (1, 0), (0, 1), (-1, 0)] # x, y???????????? (???????????????????????????)
M = [[' '] * n for _ in range(n)] # ??????????????¨?????????????????§?????????
cx = 0 # ??????????????°???
cy = n - 1
line = 0 # ???????????§??????????????????n??¨???????????°??????????????¨??????
while line < n:
dx, dy = dirs[line % 4]
line += 1
while True:
M[cy][cx] = '#'
nx = cx + dx # ?¬???????????????¨???????????????
if not 0 <= nx < n: # ??????????????????????????????????????§???????????¢?????????
break
ny = cy + dy
if not 0 <= ny < n:
break
nnx = nx + dx # ?¬?????¬???????????????¨???????????????
nny = ny + dy
if 0 <= nny < n and 0 <= nnx < n:
if M[nny][nnx] != ' ': # ??????????????????????????????????????¢??????????????????????????£??????????????´??????????????¢?????????
break
cx = nx
cy = ny
# ?????????????????????????????????
for l in M:
print(''.join(l))
def main(args):
n = int(input())
for i in range(n):
size = int(input())
guruguru(size)
if i != (n - 1): # ????????\?????????????????????????????????????????\??????
print()
if __name__ == '__main__':
main(sys.argv[1:])
``` | output | 1 | 53,825 | 23 | 107,651 |
Provide a correct Python 3 solution for this coding contest problem.
I decided to create a program that displays a "round and round pattern". The "round and round pattern" is as follows.
* If the length of one side is n, it is displayed as a character string with n rows and n columns.
* A spiral pattern that rotates clockwise with the lower left corner as the base point.
* The part with a line is represented by # (half-width sharp), and the blank part is represented by "" (half-width blank).
* Leave a space between the lines.
Create a program that takes an integer n as an input and outputs a "round and round pattern" with a side length of n.
Input
The input is given in the following format:
d
n1
n2
::
nd
The number of datasets d (d ≤ 20) is given to the first line, and the side length ni (1 ≤ ni ≤ 100) of the i-th round pattern is given to each of the following d lines.
Output
Please output a round and round pattern for each data set. Insert a blank line between the datasets.
Example
Input
2
5
6
Output
#####
# #
# # #
# # #
# ###
######
# #
# ## #
# # #
# # #
# #### | instruction | 0 | 53,826 | 23 | 107,652 |
"Correct Solution:
```
# -*- coding: utf-8 -*-
"""
http://judge.u-aizu.ac.jp/onlinejudge/description.jsp?id=0141
"""
import sys
from sys import stdin
input = stdin.readline
from itertools import cycle
def guruguru(n):
line = 0
dirs = cycle([(0, -1), (1, 0), (0, 1), (-1, 0)])
M = [[' '] * n for _ in range(n)]
cx = 0
cy = n - 1
while line < n:
line += 1
dx, dy = dirs.__next__()
while True:
M[cy][cx] = '#'
nx = cx + dx
ny = cy + dy
nnx = nx + dx
nny = ny + dy
if nx < 0 or nx >= n:
break
if ny < 0 or ny >= n:
break
if nny < 0 or nny >= n or nnx < 0 or nnx >= n:
pass
else:
if M[nny][nnx] != ' ':
break
cx = nx
cy = ny
for l in M:
print(''.join(map(str, l)))
def main(args):
n = int(input())
for i in range(n):
size = int(input())
guruguru(size)
if i != (n - 1):
print()
if __name__ == '__main__':
main(sys.argv[1:])
``` | output | 1 | 53,826 | 23 | 107,653 |
Provide a correct Python 3 solution for this coding contest problem.
I decided to create a program that displays a "round and round pattern". The "round and round pattern" is as follows.
* If the length of one side is n, it is displayed as a character string with n rows and n columns.
* A spiral pattern that rotates clockwise with the lower left corner as the base point.
* The part with a line is represented by # (half-width sharp), and the blank part is represented by "" (half-width blank).
* Leave a space between the lines.
Create a program that takes an integer n as an input and outputs a "round and round pattern" with a side length of n.
Input
The input is given in the following format:
d
n1
n2
::
nd
The number of datasets d (d ≤ 20) is given to the first line, and the side length ni (1 ≤ ni ≤ 100) of the i-th round pattern is given to each of the following d lines.
Output
Please output a round and round pattern for each data set. Insert a blank line between the datasets.
Example
Input
2
5
6
Output
#####
# #
# # #
# # #
# ###
######
# #
# ## #
# # #
# # #
# #### | instruction | 0 | 53,827 | 23 | 107,654 |
"Correct Solution:
```
class Vector:
def __init__(self, x, y):
self.x = x
self.y = y
def move(self, offset):
self.x += offset[0]
self.y += offset[1]
def move_offset(self, offset, multiple=1):
x = self.x + offset[0] * multiple
y = self.y + offset[1] * multiple
return Vector(x, y)
class Pattern:
NOTHING = " "
EXIST = "#"
SENTINEL = "?"
MOVE = [
[[-1, -1], [-1, +0], [-1, +1]],
[[-1, +1], [-0, +1], [+1, +1]],
[[+1, +1], [+1, +0], [+1, -1]],
[[+1, -1], [+0, -1], [-1, -1]],
]
@classmethod
def create_area(cls, size):
area = [[cls.SENTINEL] * 2 + [cls.NOTHING] * size + [cls.SENTINEL] * 2 for _ in range(size)]
tmp = [[cls.SENTINEL] * size + [cls.SENTINEL] * 2 * 2]
area = tmp * 2 + area + tmp * 2
return area
@classmethod
def even_spiral_pattern(cls, area, point):
move_index = 0
area[point.x][point.y] = cls.EXIST
while True:
left, center, right = cls.MOVE[move_index]
end1, end2 = point.move_offset(left), point.move_offset(right)
offset, offset2 = point.move_offset(center), point.move_offset(center, 2)
if area[end1.x][end1.y] == cls.EXIST or area[end2.x][end2.y] == cls.EXIST:
return area
elif area[offset.x][offset.y] == cls.NOTHING and area[offset2.x][offset2.y] != cls.EXIST:
point.move(center)
area[point.x][point.y] = cls.EXIST
else:
move_index += 1
move_index %= 4
@classmethod
def odd_spiral_pattern(cls, area, point):
move_index = 0
is_end = False
area[point.x][point.y] = cls.EXIST
while True:
left, center, right = cls.MOVE[move_index]
offset, offset2 = point.move_offset(center), point.move_offset(center, 2)
if area[offset.x][offset.y] == cls.NOTHING and area[offset2.x][offset2.y] != cls.EXIST:
point.move(center)
area[point.x][point.y] = cls.EXIST
is_end = False
else:
if is_end:
return area
else:
is_end = True
move_index += 1
move_index %= 4
@classmethod
def formater(cls, area):
output = ["".join(item).replace(cls.SENTINEL, "") for item in area[2:-2]]
output = "\n".join(output)
return output
@classmethod
def solve(cls, size):
area = cls.create_area(size)
point = Vector(size - 1 + 2, 2)
if size % 2 == 0:
result = cls.even_spiral_pattern(area, point)
else:
result = cls.odd_spiral_pattern(area, point)
return cls.formater(result)
sizes = [int(input()) for _ in range(int(input()))]
results = [Pattern.solve(num) for num in sizes]
print("\n\n".join(results))
``` | output | 1 | 53,827 | 23 | 107,655 |
Provide a correct Python 3 solution for this coding contest problem.
I decided to create a program that displays a "round and round pattern". The "round and round pattern" is as follows.
* If the length of one side is n, it is displayed as a character string with n rows and n columns.
* A spiral pattern that rotates clockwise with the lower left corner as the base point.
* The part with a line is represented by # (half-width sharp), and the blank part is represented by "" (half-width blank).
* Leave a space between the lines.
Create a program that takes an integer n as an input and outputs a "round and round pattern" with a side length of n.
Input
The input is given in the following format:
d
n1
n2
::
nd
The number of datasets d (d ≤ 20) is given to the first line, and the side length ni (1 ≤ ni ≤ 100) of the i-th round pattern is given to each of the following d lines.
Output
Please output a round and round pattern for each data set. Insert a blank line between the datasets.
Example
Input
2
5
6
Output
#####
# #
# # #
# # #
# ###
######
# #
# ## #
# # #
# # #
# #### | instruction | 0 | 53,828 | 23 | 107,656 |
"Correct Solution:
```
dd = ((-1, 0), (0, -1), (1, 0), (0, 1))
d = int(input())
for i in range(d):
if i:
print()
N = int(input())
MP = [[" "]*N for i in range(N)]
for i in range(N):
MP[i][0] = "#"
def walk(x, y, d, n):
dx, dy = dd[d % 4]
for k in range(n):
x += dx; y += dy
MP[y][x] = "#"
return x, y
x = y = 0
r = N-1; d = 2
while r > 1:
x, y = walk(x, y, d, r)
x, y = walk(x, y, d+1, r)
r -= 2; d += 2
if r == 1:
walk(x, y, d, r)
for line in MP:
print(*line, sep='')
``` | output | 1 | 53,828 | 23 | 107,657 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
I decided to create a program that displays a "round and round pattern". The "round and round pattern" is as follows.
* If the length of one side is n, it is displayed as a character string with n rows and n columns.
* A spiral pattern that rotates clockwise with the lower left corner as the base point.
* The part with a line is represented by # (half-width sharp), and the blank part is represented by "" (half-width blank).
* Leave a space between the lines.
Create a program that takes an integer n as an input and outputs a "round and round pattern" with a side length of n.
Input
The input is given in the following format:
d
n1
n2
::
nd
The number of datasets d (d ≤ 20) is given to the first line, and the side length ni (1 ≤ ni ≤ 100) of the i-th round pattern is given to each of the following d lines.
Output
Please output a round and round pattern for each data set. Insert a blank line between the datasets.
Example
Input
2
5
6
Output
#####
# #
# # #
# # #
# ###
######
# #
# ## #
# # #
# # #
# ####
Submitted Solution:
```
class Vector:
def __init__(self, x, y):
self.x = x
self.y = y
def move(self, offset):
self.x += offset[0]
self.y += offset[1]
def move_offset(self, offset, multiple=1):
x = self.x + offset[0] * multiple
y = self.y + offset[1] * multiple
return Vector(x, y)
class Pattern:
NOTHING = " "
EXIST = "#"
SENTINEL = "?"
MOVE = [
[[-1, -1], [-1, +0], [-1, +1]],
[[-1, +1], [-0, +1], [+1, +1]],
[[+1, +1], [+1, +0], [+1, -1]],
[[+1, -1], [+0, -1], [-1, -1]],
]
@classmethod
def create_area(cls, size):
area = [[cls.SENTINEL] * 2 + [cls.NOTHING] * size + [cls.SENTINEL] * 2 for _ in range(size)]
tmp = [[cls.SENTINEL] * size + [cls.SENTINEL] * 2 * 2]
area = tmp * 2 + area + tmp * 2
return area
@classmethod
def even_spiral_pattern(cls, area, point):
move_index = 0
area[point.x][point.y] = cls.EXIST
while True:
left, center, right = cls.MOVE[move_index]
end1, end2 = point.move_offset(left), point.move_offset(right)
offset, offset2 = point.move_offset(center), point.move_offset(center, 2)
if area[end1.x][end1.y] == cls.EXIST or area[end2.x][end2.y] == cls.EXIST:
return area
elif area[offset.x][offset.y] == cls.NOTHING and area[offset2.x][offset2.y] != cls.EXIST:
point.move(center)
area[point.x][point.y] = cls.EXIST
else:
move_index += 1
move_index %= 4
@classmethod
def odd_spiral_pattern(cls, area, point):
move_index = 0
is_end = False
area[point.x][point.y] = cls.EXIST
while True:
left, center, right = cls.MOVE[move_index]
offset, offset2 = point.move_offset(center), point.move_offset(center, 2)
if area[offset.x][offset.y] == cls.NOTHING and area[offset2.x][offset2.y] != cls.EXIST:
point.move(center)
area[point.x][point.y] = cls.EXIST
is_end = False
else:
if is_end:
return area
else:
is_end = True
move_index += 1
move_index %= 4
@classmethod
def formater(cls, area):
output = ["".join(item[2:-2]) for item in area[2:-2]]
output = "\n".join(output)
return output
@classmethod
def solve(cls, size):
area = cls.create_area(size)
point = Vector(size - 1 + 2, 2)
if size % 2 == 0:
result = cls.even_spiral_pattern(area, point)
else:
result = cls.odd_spiral_pattern(area, point)
return cls.formater(result)
sizes = [int(input()) for _ in range(int(input()))]
results = [Pattern.solve(num) for num in sizes]
print("\n\n".join(results))
``` | instruction | 0 | 53,829 | 23 | 107,658 |
Yes | output | 1 | 53,829 | 23 | 107,659 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
I decided to create a program that displays a "round and round pattern". The "round and round pattern" is as follows.
* If the length of one side is n, it is displayed as a character string with n rows and n columns.
* A spiral pattern that rotates clockwise with the lower left corner as the base point.
* The part with a line is represented by # (half-width sharp), and the blank part is represented by "" (half-width blank).
* Leave a space between the lines.
Create a program that takes an integer n as an input and outputs a "round and round pattern" with a side length of n.
Input
The input is given in the following format:
d
n1
n2
::
nd
The number of datasets d (d ≤ 20) is given to the first line, and the side length ni (1 ≤ ni ≤ 100) of the i-th round pattern is given to each of the following d lines.
Output
Please output a round and round pattern for each data set. Insert a blank line between the datasets.
Example
Input
2
5
6
Output
#####
# #
# # #
# # #
# ###
######
# #
# ## #
# # #
# # #
# ####
Submitted Solution:
```
# AOJ 0141 Spiral Pattern
# Python3 2018.6.23 bal4u
for ci in range(int(input())):
if ci > 0: print()
n = int(input())
a = [[' ' for c in range(n+5)] for c in range(n+5)]
for r in range(0, n+4, n+3):
for c in range(n+4): a[r][c] = '#'
for c in range(0, n+4, n+3):
for r in range(n+4): a[r][c] = '#'
r, c = n+1, 2
a[r][c] = '#'
d = 'U'
stop = 0
while 1:
if stop >= 4: break
if d == 'U':
if a[r-2][c] == '#' or a[r-1][c] == '#' or a[r-1][c+1] == '#':
d = 'R'
stop += 1
else:
r -= 1
a[r][c] = '#'
stop = 0
if d == 'R':
if a[r][c+2] == '#' or a[r][c+1] == '#' or a[r+1][c+1] == '#':
d = 'D'
stop += 1
else:
c += 1
a[r][c] = '#'
stop = 0
if d == 'D':
if a[r+2][c] == '#' or a[r+1][c] == '#' or a[r+1][c-1] == '#':
d = 'L'
stop += 1
else:
r += 1
a[r][c] = '#'
stop = 0
if d == 'L':
if a[r][c-2] == '#' or a[r][c-1] == '#' or a[r-1][c-1] == '#':
d = 'U'
stop += 1
else:
c -= 1
a[r][c] = '#'
stop = 0
for r in range(2, n+2): print(*a[r][2:n+2], sep='')
``` | instruction | 0 | 53,830 | 23 | 107,660 |
Yes | output | 1 | 53,830 | 23 | 107,661 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
I decided to create a program that displays a "round and round pattern". The "round and round pattern" is as follows.
* If the length of one side is n, it is displayed as a character string with n rows and n columns.
* A spiral pattern that rotates clockwise with the lower left corner as the base point.
* The part with a line is represented by # (half-width sharp), and the blank part is represented by "" (half-width blank).
* Leave a space between the lines.
Create a program that takes an integer n as an input and outputs a "round and round pattern" with a side length of n.
Input
The input is given in the following format:
d
n1
n2
::
nd
The number of datasets d (d ≤ 20) is given to the first line, and the side length ni (1 ≤ ni ≤ 100) of the i-th round pattern is given to each of the following d lines.
Output
Please output a round and round pattern for each data set. Insert a blank line between the datasets.
Example
Input
2
5
6
Output
#####
# #
# # #
# # #
# ###
######
# #
# ## #
# # #
# # #
# ####
Submitted Solution:
```
class Vector:
def __init__(self, x, y):
self.x = x
self.y = y
def move(self, offset):
self.x += offset[0]
self.y += offset[1]
def move_offset(self, offset, multiple=1):
x = self.x + offset[0] * multiple
y = self.y + offset[1] * multiple
return Vector(x, y)
NOTHING = " "
EXIST = "#"
SENTINEL = "?"
MOVE = [
[[-1, -1], [-1, +0], [-1, +1]],
[[-1, +1], [-0, +1], [+1, +1]],
[[+1, +1], [+1, +0], [+1, -1]],
[[+1, -1], [+0, -1], [-1, -1]],
]
def create_area(size):
area = [[SENTINEL] * 2 + [NOTHING] * size + [SENTINEL] * 2 for _ in range(size)]
tmp = [[SENTINEL] * size + [SENTINEL] * 2 * 2]
area = tmp * 2 + area + tmp * 2
return area
def even_spiral_pattern(area, point):
move_index = 0
area[point.x][point.y] = EXIST
while True:
left, center, right = MOVE[move_index]
end1, end2 = point.move_offset(left), point.move_offset(right)
offset, offset2 = point.move_offset(center), point.move_offset(center, 2)
if area[end1.x][end1.y] == EXIST or area[end2.x][end2.y] == EXIST:
return area
elif area[offset.x][offset.y] == NOTHING and area[offset2.x][offset2.y] != EXIST:
point.move(center)
area[point.x][point.y] = EXIST
else:
move_index += 1
move_index %= 4
def odd_spiral_pattern(area, point):
move_index = 0
is_end = False
area[point.x][point.y] = EXIST
while True:
left, center, right = MOVE[move_index]
offset, offset2 = point.move_offset(center), point.move_offset(center, 2)
if area[offset.x][offset.y] == NOTHING and area[offset2.x][offset2.y] != EXIST:
point.move(center)
area[point.x][point.y] = EXIST
is_end = False
else:
if is_end:
return area
else:
is_end = True
move_index += 1
move_index %= 4
def formater(area):
output = ["".join(item).replace(SENTINEL, "") for item in result[2:-2]]
output = "\n".join(output)
return output
output = []
for _ in range(int(input())):
size = int(input())
area = create_area(size)
point = Vector(size - 1 + 2, 2)
if size % 2 == 0:
result = even_spiral_pattern(area, point)
else:
result = odd_spiral_pattern(area, point)
output.append(formater(result))
print("\n\n".join(output))
``` | instruction | 0 | 53,831 | 23 | 107,662 |
Yes | output | 1 | 53,831 | 23 | 107,663 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
I decided to create a program that displays a "round and round pattern". The "round and round pattern" is as follows.
* If the length of one side is n, it is displayed as a character string with n rows and n columns.
* A spiral pattern that rotates clockwise with the lower left corner as the base point.
* The part with a line is represented by # (half-width sharp), and the blank part is represented by "" (half-width blank).
* Leave a space between the lines.
Create a program that takes an integer n as an input and outputs a "round and round pattern" with a side length of n.
Input
The input is given in the following format:
d
n1
n2
::
nd
The number of datasets d (d ≤ 20) is given to the first line, and the side length ni (1 ≤ ni ≤ 100) of the i-th round pattern is given to each of the following d lines.
Output
Please output a round and round pattern for each data set. Insert a blank line between the datasets.
Example
Input
2
5
6
Output
#####
# #
# # #
# # #
# ###
######
# #
# ## #
# # #
# # #
# ####
Submitted Solution:
```
# -*- coding: utf-8 -*-
"""
http://judge.u-aizu.ac.jp/onlinejudge/description.jsp?id=0141
"""
import sys
from sys import stdin
input = stdin.readline
from itertools import cycle
def guruguru(n):
line = 0
dirs = cycle([(0, -1), (1, 0), (0, 1), (-1, 0)])
M = [[' '] * n for _ in range(n)]
cx = 0
cy = n - 1
while line < n:
line += 1
dx, dy = dirs.__next__()
while True:
M[cy][cx] = '#'
nx = cx + dx
ny = cy + dy
nnx = nx + dx
nny = ny + dy
if nx < 0 or nx >= n:
break
if ny < 0 or ny >= n:
break
if nny < 0 or nny >= n or nnx < 0 or nnx >= n:
pass
else:
if M[nny][nnx] != ' ':
break
cx = nx
cy = ny
for l in M:
print(''.join(map(str, l)))
def main(args):
n = int(input())
for _ in range(n):
size = int(input())
guruguru(size)
if __name__ == '__main__':
main(sys.argv[1:])
``` | instruction | 0 | 53,832 | 23 | 107,664 |
No | output | 1 | 53,832 | 23 | 107,665 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
I decided to create a program that displays a "round and round pattern". The "round and round pattern" is as follows.
* If the length of one side is n, it is displayed as a character string with n rows and n columns.
* A spiral pattern that rotates clockwise with the lower left corner as the base point.
* The part with a line is represented by # (half-width sharp), and the blank part is represented by "" (half-width blank).
* Leave a space between the lines.
Create a program that takes an integer n as an input and outputs a "round and round pattern" with a side length of n.
Input
The input is given in the following format:
d
n1
n2
::
nd
The number of datasets d (d ≤ 20) is given to the first line, and the side length ni (1 ≤ ni ≤ 100) of the i-th round pattern is given to each of the following d lines.
Output
Please output a round and round pattern for each data set. Insert a blank line between the datasets.
Example
Input
2
5
6
Output
#####
# #
# # #
# # #
# ###
######
# #
# ## #
# # #
# # #
# ####
Submitted Solution:
```
vector = ((0, -1), (1, 0), (0, 1), (-1, 0))
def make_guruguru(d):
lst = [["#"] * (d + 4)]
for _ in range(d + 2):
lst.append(["#"] + [" "] * (d + 2) + ["#"])
lst.append(["#"] * (d + 4))
x, y = 2, d + 1
lst[y][x] = "#"
direct = 0
vx, vy = vector[0]
cnt = 1
while True:
while lst[y + vy * 2][x + vx * 2] == " ":
lst[y + vy][x + vx] = "#"
y += vy
x += vx
cnt += 1
if cnt <= 1:
break
direct = (direct + 1) % 4
vx, vy = vector[direct]
cnt = 0
for y in range(2, d + 2):
print("".join(lst[y][2:-2]))
print()
for line in lst:
print("".join(line))
n = int(input())
for _ in range(n):
d = int(input())
make_guruguru(d)
``` | instruction | 0 | 53,833 | 23 | 107,666 |
No | output | 1 | 53,833 | 23 | 107,667 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
I decided to create a program that displays a "round and round pattern". The "round and round pattern" is as follows.
* If the length of one side is n, it is displayed as a character string with n rows and n columns.
* A spiral pattern that rotates clockwise with the lower left corner as the base point.
* The part with a line is represented by # (half-width sharp), and the blank part is represented by "" (half-width blank).
* Leave a space between the lines.
Create a program that takes an integer n as an input and outputs a "round and round pattern" with a side length of n.
Input
The input is given in the following format:
d
n1
n2
::
nd
The number of datasets d (d ≤ 20) is given to the first line, and the side length ni (1 ≤ ni ≤ 100) of the i-th round pattern is given to each of the following d lines.
Output
Please output a round and round pattern for each data set. Insert a blank line between the datasets.
Example
Input
2
5
6
Output
#####
# #
# # #
# # #
# ###
######
# #
# ## #
# # #
# # #
# ####
Submitted Solution:
```
# -*- coding: utf-8 -*-
"""
http://judge.u-aizu.ac.jp/onlinejudge/description.jsp?id=0141
"""
import sys
from sys import stdin
input = stdin.readline
from itertools import cycle
def guruguru(n):
if n < 5:
return
line = 0
dirs = cycle([(0, -1), (1, 0), (0, 1), (-1, 0)])
M = [[' '] * n for _ in range(n)]
cx = 0
cy = n - 1
while line < n:
line += 1
dx, dy = dirs.__next__()
while True:
M[cy][cx] = '#'
nx = cx + dx
ny = cy + dy
nnx = nx + dx
nny = ny + dy
if nx < 0 or nx >= n:
break
if ny < 0 or ny >= n:
break
if nny < 0 or nny >= n or nnx < 0 or nnx >= n:
pass
else:
if M[nny][nnx] != ' ':
break
cx = nx
cy = ny
for l in M:
print(''.join(map(str, l)))
def main(args):
for line in sys.stdin:
n = int(line)
guruguru(n)
if __name__ == '__main__':
main(sys.argv[1:])
``` | instruction | 0 | 53,834 | 23 | 107,668 |
No | output | 1 | 53,834 | 23 | 107,669 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
I decided to create a program that displays a "round and round pattern". The "round and round pattern" is as follows.
* If the length of one side is n, it is displayed as a character string with n rows and n columns.
* A spiral pattern that rotates clockwise with the lower left corner as the base point.
* The part with a line is represented by # (half-width sharp), and the blank part is represented by "" (half-width blank).
* Leave a space between the lines.
Create a program that takes an integer n as an input and outputs a "round and round pattern" with a side length of n.
Input
The input is given in the following format:
d
n1
n2
::
nd
The number of datasets d (d ≤ 20) is given to the first line, and the side length ni (1 ≤ ni ≤ 100) of the i-th round pattern is given to each of the following d lines.
Output
Please output a round and round pattern for each data set. Insert a blank line between the datasets.
Example
Input
2
5
6
Output
#####
# #
# # #
# # #
# ###
######
# #
# ## #
# # #
# # #
# ####
Submitted Solution:
```
class Vector:
def __init__(self, x, y):
self.x = x
self.y = y
def move(self, offset):
self.x += offset[0]
self.y += offset[1]
def move_offset(self, offset, multiple=1):
x = self.x + offset[0] * multiple
y = self.y + offset[1] * multiple
return Vector(x, y)
NOTHING = " "
EXIST = "#"
SENTINEL = "?"
MOVE = [
[[-1, -1], [-1, +0], [-1, +1]],
[[-1, +1], [-0, +1], [+1, +1]],
[[+1, +1], [+1, +0], [+1, -1]],
[[+1, -1], [+0, -1], [-1, -1]],
]
def create_area(size):
area = [[SENTINEL] * 2 + [NOTHING] * size + [SENTINEL] * 2 for _ in range(size)]
tmp = [[SENTINEL] * size + [SENTINEL] * 2 * 2]
area = tmp * 2 + area + tmp * 2
return area
def even_spiral_pattern(area, point):
move_index = 0
area[point.x][point.y] = EXIST
while True:
left, center, right = MOVE[move_index]
end1, end2 = point.move_offset(left), point.move_offset(right)
offset, offset2 = point.move_offset(center), point.move_offset(center, 2)
if area[end1.x][end1.y] == EXIST or area[end2.x][end2.y] == EXIST:
return area
elif area[offset.x][offset.y] == NOTHING and area[offset2.x][offset2.y] != EXIST:
point.move(center)
area[point.x][point.y] = EXIST
else:
move_index += 1
move_index %= 4
def odd_spiral_pattern(area, point):
move_index = 0
is_end = False
area[point.x][point.y] = EXIST
while True:
left, center, right = MOVE[move_index]
offset, offset2 = point.move_offset(center), point.move_offset(center, 2)
if area[offset.x][offset.y] == NOTHING and area[offset2.x][offset2.y] != EXIST:
point.move(center)
area[point.x][point.y] = EXIST
is_end = False
else:
if is_end:
return area
else:
is_end = True
move_index += 1
move_index %= 4
def output(area):
output = ["".join(item).replace(SENTINEL, "") for item in result[2:-2]]
output = "\n".join(output)
return output
for _ in range(int(input())):
size = int(input())
area = create_area(size)
point = Vector(size - 1 + 2, 2)
if size % 2 == 0:
result = even_spiral_pattern(area, point)
else:
result = odd_spiral_pattern(area, point)
print(output(result))
``` | instruction | 0 | 53,835 | 23 | 107,670 |
No | output | 1 | 53,835 | 23 | 107,671 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
Write a program which calculates the distance between two points P1(x1, y1) and P2(x2, y2).
Input
Four real numbers x1, y1, x2 and y2 are given in a line.
Output
Print the distance in real number. The output should not contain an absolute error greater than 10-4.
Example
Input
0 0 1 1
Output
1.41421356
Submitted Solution:
```
from math import sqrt
a,b,c,d = map(float,input().split())
print(sqrt((c-a)**2+(d-b)**2))
``` | instruction | 0 | 53,920 | 23 | 107,840 |
Yes | output | 1 | 53,920 | 23 | 107,841 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
Write a program which calculates the distance between two points P1(x1, y1) and P2(x2, y2).
Input
Four real numbers x1, y1, x2 and y2 are given in a line.
Output
Print the distance in real number. The output should not contain an absolute error greater than 10-4.
Example
Input
0 0 1 1
Output
1.41421356
Submitted Solution:
```
import math
x1, y1, x2, y2 = map(float, input(). split())
print(math.hypot(x1-x2,y1-y2))
``` | instruction | 0 | 53,921 | 23 | 107,842 |
Yes | output | 1 | 53,921 | 23 | 107,843 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
Write a program which calculates the distance between two points P1(x1, y1) and P2(x2, y2).
Input
Four real numbers x1, y1, x2 and y2 are given in a line.
Output
Print the distance in real number. The output should not contain an absolute error greater than 10-4.
Example
Input
0 0 1 1
Output
1.41421356
Submitted Solution:
```
w, x, y, z = map(float, input().split())
print('%5f' % ((w - y)**2 + (x - z)**2)**0.5)
``` | instruction | 0 | 53,923 | 23 | 107,846 |
Yes | output | 1 | 53,923 | 23 | 107,847 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
Write a program which calculates the distance between two points P1(x1, y1) and P2(x2, y2).
Input
Four real numbers x1, y1, x2 and y2 are given in a line.
Output
Print the distance in real number. The output should not contain an absolute error greater than 10-4.
Example
Input
0 0 1 1
Output
1.41421356
Submitted Solution:
```
x1, y1, x2, y2 = map(float, input().split())
import math
print("{0.8}".format(math.sqrt(x1*x2 + y1*y2)))
``` | instruction | 0 | 53,924 | 23 | 107,848 |
No | output | 1 | 53,924 | 23 | 107,849 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
As you could know there are no male planes nor female planes. However, each plane on Earth likes some other plane. There are n planes on Earth, numbered from 1 to n, and the plane with number i likes the plane with number fi, where 1 ≤ fi ≤ n and fi ≠ i.
We call a love triangle a situation in which plane A likes plane B, plane B likes plane C and plane C likes plane A. Find out if there is any love triangle on Earth.
Input
The first line contains a single integer n (2 ≤ n ≤ 5000) — the number of planes.
The second line contains n integers f1, f2, ..., fn (1 ≤ fi ≤ n, fi ≠ i), meaning that the i-th plane likes the fi-th.
Output
Output «YES» if there is a love triangle consisting of planes on Earth. Otherwise, output «NO».
You can output any letter in lower case or in upper case.
Examples
Input
5
2 4 5 1 3
Output
YES
Input
5
5 5 5 5 1
Output
NO
Note
In first example plane 2 likes plane 4, plane 4 likes plane 1, plane 1 likes plane 2 and that is a love triangle.
In second example there are no love triangles.
Submitted Solution:
```
n=int(input())
a=list(map(int,input().split()))
flag=0
for i in range(n):
if a[a[a[i]-1]-1]==i+1:
flag=1
if flag==1:
print("YES")
else:
print("NO")
``` | instruction | 0 | 54,510 | 23 | 109,020 |
Yes | output | 1 | 54,510 | 23 | 109,021 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
As you could know there are no male planes nor female planes. However, each plane on Earth likes some other plane. There are n planes on Earth, numbered from 1 to n, and the plane with number i likes the plane with number fi, where 1 ≤ fi ≤ n and fi ≠ i.
We call a love triangle a situation in which plane A likes plane B, plane B likes plane C and plane C likes plane A. Find out if there is any love triangle on Earth.
Input
The first line contains a single integer n (2 ≤ n ≤ 5000) — the number of planes.
The second line contains n integers f1, f2, ..., fn (1 ≤ fi ≤ n, fi ≠ i), meaning that the i-th plane likes the fi-th.
Output
Output «YES» if there is a love triangle consisting of planes on Earth. Otherwise, output «NO».
You can output any letter in lower case or in upper case.
Examples
Input
5
2 4 5 1 3
Output
YES
Input
5
5 5 5 5 1
Output
NO
Note
In first example plane 2 likes plane 4, plane 4 likes plane 1, plane 1 likes plane 2 and that is a love triangle.
In second example there are no love triangles.
Submitted Solution:
```
#_________________ Mukul Mohan Varshney _______________#
#Template
import sys
import os
import math
import copy
from math import gcd
from bisect import bisect
from io import BytesIO, IOBase
from math import sqrt,floor,factorial,gcd,log,ceil
from collections import deque,Counter,defaultdict
from itertools import permutations, combinations
#define function
def Int(): return int(sys.stdin.readline())
def Mint(): return map(int,sys.stdin.readline().split())
def Lstr(): return list(sys.stdin.readline().strip())
def Str(): return sys.stdin.readline().strip()
def Mstr(): return map(str,sys.stdin.readline().strip().split())
def List(): return list(map(int,sys.stdin.readline().split()))
def Hash(): return dict()
def Mod(): return 1000000007
def Ncr(n,r,p): return ((fact[n])*((ifact[r]*ifact[n-r])%p))%p
def Most_frequent(list): return max(set(list), key = list.count)
def Mat2x2(n): return [List() for _ in range(n)]
def Divisors(n) :
l = []
for i in range(1, int(math.sqrt(n) + 1)) :
if (n % i == 0) :
if (n // i == i) :
l.append(i)
else :
l.append(i)
l.append(n//i)
return l
def GCD(x,y):
while(y):
x, y = y, x % y
return x
def minimum_integer_not_in_list(a):
b=max(a)
if(b<1):
return 1
A=set(a)
B=set(range(1,b+1))
D=B-A
if len(D)==0:
return b+1
else:
return min(D)
# Driver Code
def solution():
n=Int()
a=List()
for i in range(n):
if(a[a[a[i]-1]-1]==i+1):
print("YES")
sys.exit(0)
print("NO")
#Call the solve function
if __name__ == "__main__":
solution()
``` | instruction | 0 | 54,511 | 23 | 109,022 |
Yes | output | 1 | 54,511 | 23 | 109,023 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
As you could know there are no male planes nor female planes. However, each plane on Earth likes some other plane. There are n planes on Earth, numbered from 1 to n, and the plane with number i likes the plane with number fi, where 1 ≤ fi ≤ n and fi ≠ i.
We call a love triangle a situation in which plane A likes plane B, plane B likes plane C and plane C likes plane A. Find out if there is any love triangle on Earth.
Input
The first line contains a single integer n (2 ≤ n ≤ 5000) — the number of planes.
The second line contains n integers f1, f2, ..., fn (1 ≤ fi ≤ n, fi ≠ i), meaning that the i-th plane likes the fi-th.
Output
Output «YES» if there is a love triangle consisting of planes on Earth. Otherwise, output «NO».
You can output any letter in lower case or in upper case.
Examples
Input
5
2 4 5 1 3
Output
YES
Input
5
5 5 5 5 1
Output
NO
Note
In first example plane 2 likes plane 4, plane 4 likes plane 1, plane 1 likes plane 2 and that is a love triangle.
In second example there are no love triangles.
Submitted Solution:
```
t=int(input())
l=list(map(int,input().split()))
y=0
for i in range(t):
a=l[i]
b=l[a-1]
if l[b-1]==i+1:
print("YES")
y=1
break
if y==0:
print("NO")
``` | instruction | 0 | 54,512 | 23 | 109,024 |
Yes | output | 1 | 54,512 | 23 | 109,025 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
As you could know there are no male planes nor female planes. However, each plane on Earth likes some other plane. There are n planes on Earth, numbered from 1 to n, and the plane with number i likes the plane with number fi, where 1 ≤ fi ≤ n and fi ≠ i.
We call a love triangle a situation in which plane A likes plane B, plane B likes plane C and plane C likes plane A. Find out if there is any love triangle on Earth.
Input
The first line contains a single integer n (2 ≤ n ≤ 5000) — the number of planes.
The second line contains n integers f1, f2, ..., fn (1 ≤ fi ≤ n, fi ≠ i), meaning that the i-th plane likes the fi-th.
Output
Output «YES» if there is a love triangle consisting of planes on Earth. Otherwise, output «NO».
You can output any letter in lower case or in upper case.
Examples
Input
5
2 4 5 1 3
Output
YES
Input
5
5 5 5 5 1
Output
NO
Note
In first example plane 2 likes plane 4, plane 4 likes plane 1, plane 1 likes plane 2 and that is a love triangle.
In second example there are no love triangles.
Submitted Solution:
```
n = int(input())
f = [0] + [int(i) for i in input().split()]
t = 0
for i in range(1, n+1):
if f[f[f[i]]] == i: t = 1
if t: print("YES")
else: print("NO")
``` | instruction | 0 | 54,513 | 23 | 109,026 |
Yes | output | 1 | 54,513 | 23 | 109,027 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
As you could know there are no male planes nor female planes. However, each plane on Earth likes some other plane. There are n planes on Earth, numbered from 1 to n, and the plane with number i likes the plane with number fi, where 1 ≤ fi ≤ n and fi ≠ i.
We call a love triangle a situation in which plane A likes plane B, plane B likes plane C and plane C likes plane A. Find out if there is any love triangle on Earth.
Input
The first line contains a single integer n (2 ≤ n ≤ 5000) — the number of planes.
The second line contains n integers f1, f2, ..., fn (1 ≤ fi ≤ n, fi ≠ i), meaning that the i-th plane likes the fi-th.
Output
Output «YES» if there is a love triangle consisting of planes on Earth. Otherwise, output «NO».
You can output any letter in lower case or in upper case.
Examples
Input
5
2 4 5 1 3
Output
YES
Input
5
5 5 5 5 1
Output
NO
Note
In first example plane 2 likes plane 4, plane 4 likes plane 1, plane 1 likes plane 2 and that is a love triangle.
In second example there are no love triangles.
Submitted Solution:
```
from collections import defaultdict
n= int(input())
arr=list(map(int,input().split()))
graph = defaultdict(list)
for i in range(n):
graph[i].append(arr[i])
def isCyclicUtil(v,visited,recStack):
visited.append(v)
recStack.append(v)
for neighbour in graph[v]:
if neighbour not in visited:
if isCyclicUtil(neighbour,visited,recStack)==True:
return True
elif neighbour in recStack:
return True
recStack.remove(v)
return False
def isCyclic(graph):
visited=[]
recStack=[]
for i in range(n):
if i not in visited:
if isCyclicUtil(i,visited,recStack)==True:
return True
return False
if isCyclic(graph):
print('YES')
else:
print('NO')
``` | instruction | 0 | 54,514 | 23 | 109,028 |
No | output | 1 | 54,514 | 23 | 109,029 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
As you could know there are no male planes nor female planes. However, each plane on Earth likes some other plane. There are n planes on Earth, numbered from 1 to n, and the plane with number i likes the plane with number fi, where 1 ≤ fi ≤ n and fi ≠ i.
We call a love triangle a situation in which plane A likes plane B, plane B likes plane C and plane C likes plane A. Find out if there is any love triangle on Earth.
Input
The first line contains a single integer n (2 ≤ n ≤ 5000) — the number of planes.
The second line contains n integers f1, f2, ..., fn (1 ≤ fi ≤ n, fi ≠ i), meaning that the i-th plane likes the fi-th.
Output
Output «YES» if there is a love triangle consisting of planes on Earth. Otherwise, output «NO».
You can output any letter in lower case or in upper case.
Examples
Input
5
2 4 5 1 3
Output
YES
Input
5
5 5 5 5 1
Output
NO
Note
In first example plane 2 likes plane 4, plane 4 likes plane 1, plane 1 likes plane 2 and that is a love triangle.
In second example there are no love triangles.
Submitted Solution:
```
n=int(input())
planes={}
visited=[]
foundcouple=[False]*n
for i,plane in enumerate(list(map(int,input().split()))):
planes[i+1]=plane
for i in range(n):
if foundcouple[i]==False:
lastkey=list(planes.keys())[i]
mem=list(planes.keys())[i]
while planes[lastkey] in planes and planes[lastkey] not in set(visited):
visited.append(lastkey)
lastkey=planes[lastkey]
visited.append(lastkey)
if planes[lastkey]==mem:
for j in set(visited):
foundcouple[j-1]=True
break
print("YES" if len(set(visited))==n else "NO")
``` | instruction | 0 | 54,515 | 23 | 109,030 |
No | output | 1 | 54,515 | 23 | 109,031 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
As you could know there are no male planes nor female planes. However, each plane on Earth likes some other plane. There are n planes on Earth, numbered from 1 to n, and the plane with number i likes the plane with number fi, where 1 ≤ fi ≤ n and fi ≠ i.
We call a love triangle a situation in which plane A likes plane B, plane B likes plane C and plane C likes plane A. Find out if there is any love triangle on Earth.
Input
The first line contains a single integer n (2 ≤ n ≤ 5000) — the number of planes.
The second line contains n integers f1, f2, ..., fn (1 ≤ fi ≤ n, fi ≠ i), meaning that the i-th plane likes the fi-th.
Output
Output «YES» if there is a love triangle consisting of planes on Earth. Otherwise, output «NO».
You can output any letter in lower case or in upper case.
Examples
Input
5
2 4 5 1 3
Output
YES
Input
5
5 5 5 5 1
Output
NO
Note
In first example plane 2 likes plane 4, plane 4 likes plane 1, plane 1 likes plane 2 and that is a love triangle.
In second example there are no love triangles.
Submitted Solution:
```
n = int(input())
x = list(map(lambda x: int(x)-1, input().split()))
if len(set(x)) <= 2:
print("NO")
exit()
flag = None
def dfs(i, lis=[]):
global flag
if x[i] in lis:
if len(lis) == 2:
flag = True
return
dfs(x[i], lis+[i])
for i in range(len(x)):
dfs(i)
if flag:
print("YES")
exit()
print("NO")
``` | instruction | 0 | 54,516 | 23 | 109,032 |
No | output | 1 | 54,516 | 23 | 109,033 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
As you could know there are no male planes nor female planes. However, each plane on Earth likes some other plane. There are n planes on Earth, numbered from 1 to n, and the plane with number i likes the plane with number fi, where 1 ≤ fi ≤ n and fi ≠ i.
We call a love triangle a situation in which plane A likes plane B, plane B likes plane C and plane C likes plane A. Find out if there is any love triangle on Earth.
Input
The first line contains a single integer n (2 ≤ n ≤ 5000) — the number of planes.
The second line contains n integers f1, f2, ..., fn (1 ≤ fi ≤ n, fi ≠ i), meaning that the i-th plane likes the fi-th.
Output
Output «YES» if there is a love triangle consisting of planes on Earth. Otherwise, output «NO».
You can output any letter in lower case or in upper case.
Examples
Input
5
2 4 5 1 3
Output
YES
Input
5
5 5 5 5 1
Output
NO
Note
In first example plane 2 likes plane 4, plane 4 likes plane 1, plane 1 likes plane 2 and that is a love triangle.
In second example there are no love triangles.
Submitted Solution:
```
def main():
N = int(input())
F = tuple(map(int, input().split()))
for i, b in enumerate(F):
try:
c = F.index(i+1)
except ValueError:
continue
if b == c:
print('YES')
break
else:
print('NO')
main()
``` | instruction | 0 | 54,517 | 23 | 109,034 |
No | output | 1 | 54,517 | 23 | 109,035 |
Provide a correct Python 3 solution for this coding contest problem.
F --Land inheritance
Problem Statement
One $ N $ brother was discussing the inheritance of his parents. The vast heritage left by their parents included vast lands. The land has a rectangular shape extending $ H $ km from north to south and $ W $ km from east to west. This land is managed in units of 1 km square, 1 km square within the range of $ i $ to $ i + 1 $ km from the north end of the land and $ j $ to $ j + 1 $ km from the west end. The partition is called partition $ (i, j) $. ($ i $, $ j $ is an integer that satisfies $ 0 \ leq i <H $, $ 0 \ leq j <W $.) The land price is fixed for each lot, and the lot $ (i, j) $ The price of is represented by $ a_ {i, j} $.
The brothers decided to divide the land and inherit it as follows.
* $ N $ Each of the siblings chooses some parcels and inherits them.
* The parcels must be chosen so that the land inherited by each sibling forms a rectangle.
* $ N $ Lands inherited by brothers must not overlap.
* There may be compartments where no one inherits. The parcels that no one inherits are abandoned.
The sum of the prices of the lots included in the range of land inherited by a person is called the price of the land. The brothers want to divide the land so that the price of the land they inherit is as fair as possible. Your job is to think of ways to divide the land that maximizes the price of the land of the person with the lowest inherited land price among the $ N $ people. Create a program that answers the land price of the person with the lowest inherited land price when the land is divided in this way.
Input
The input is given in the following format.
$ H $ $ W $ $ N $
$ a_ {0,0} $ $ a_ {0,1} $ ... $ a_ {0, W-1} $
...
$ a_ {H-1,0} $ $ a_ {H-1,1} $ ... $ a_ {H-1, W-1} $
$ H $, $ W $$ (2 \ leq H, W \ leq 200) $ represent the north-south length and the east-west length of the heritage land, respectively. $ N $$ (2 \ leq N \ leq 4) $ represents the number of siblings who inherit the land. $ a_ {i, j} $$ (0 \ leq a_ {i, j} \ leq 10 ^ 4) $ represents the price of the partition $ (i, j) $.
Output
Output the lowest land price in one line when the land price of the person with the lowest inherited land price is divided so as to maximize the land price.
Sample Input 1
3 3 2
1 2 2
3 1 0
0 4 3
Output for the Sample Input 1
7
It is best to divide as shown in the figure.
<image>
Sample Input 2
3 3 2
0 1 0
1 1 1
0 1 0
Output for the Sample Input 2
1
Sample Input 3
2 5 3
8 3 0 5 6
2 5 2 5 2
Output for the Sample Input 3
11
Sample Input 4
3 3 4
3 3 4
3 3 4
3 3 4
Output for the Sample Input 4
7
Sample Input 5
4 4 4
2 2 2 2
2 1 2 1
2 2 2 2
2 1 2 1
Output for the Sample Input 5
7
Example
Input
3 3 2
1 2 2
3 1 0
0 4 3
Output
7 | instruction | 0 | 54,745 | 23 | 109,490 |
"Correct Solution:
```
import sys
readline = sys.stdin.readline
write = sys.stdout.write
def rotate(H, W, R0):
R1 = [[0]*H for i in range(W)]
for i in range(H):
for j in range(W):
R1[W-1-j][i] = R0[i][j]
return R1
def make(H, W, R0):
R1 = [[0]*(W+1) for i in range(H+1)]
for i in range(H):
c = 0
for j in range(W):
c += R0[i][j]
R1[i+1][j+1] = c + R1[i][j+1]
return R1
def solve():
H, W, N = map(int, readline().split())
S = [list(map(int, readline().split())) for i in range(H)]
su = sum(map(sum, S))
ans = 0
if N == 2:
T = make(H, W, S)
for i in range(H+1):
e = T[i][W]
ans = max(ans, min(e, su-e))
for i in range(W+1):
e = T[H][i]
ans = max(ans, min(e, su-e))
elif N == 3:
for t in range(4):
T = make(H, W, S)
for i in range(H+1):
e0 = T[i][W]
for j in range(W+1):
e1 = T[H][j] - T[i][j]
ans = max(ans, min(e0, e1, su - e0 - e1))
if t < 2:
for i in range(W+1):
e0 = T[H][i]
for j in range(i, W+1):
e1 = T[H][j]
ans = max(ans, min(e0, e1-e0, su-e1))
S = rotate(H, W, S)
H, W = W, H
else:
for t in range(4):
T = make(H, W, S)
for i in range(H+1):
for j in range(W+1):
e0 = T[i][j]
if e0 < ans:
continue
k1 = 0
while k1 < H and T[k1][W] - T[k1][j] < e0:
k1 += 1
k2 = 0
while k2 < W and T[H][k2] - T[i][k2] < e0:
k2 += 1
if i < k1 and j < k2:
continue
if k1 <= i and k2 <= j:
v1 = su - T[H][k2] - T[i][W] + T[i][k2]
v2 = su - T[k1][W] - T[H][j] + T[k1][j]
if max(v1, v2) >= e0:
ans = max(e0, ans)
else:
v1 = su - T[H][k2] - T[k1][W] + T[k1][k2]
if v1 >= e0:
ans = max(e0, ans)
for i in range(W, -1, -1):
e0 = T[H][i]
if e0 <= ans:
break
for j in range(i, W+1):
e = T[H][j]
e1 = e - e0; e2 = su - e
if e1 <= ans or e2 <= ans:
continue
for k in range(j, W+1):
f = T[H][k]
if su-f <= ans:
break
ans = max(ans, min(e0, e1, f-e, su-f))
for k in range(H+1):
f = T[k][j] - T[k][i]
if e1-f <= ans:
break
ans = max(ans, min(e0, f, e1-f, e2))
for k in range(H+1):
f = T[k][W] - T[k][j]
if e2-f <= ans:
break
ans = max(ans, min(e0, e1, f, e2-f))
for j in range(H+1):
e1 = T[j][W] - T[j][i]
e2 = su - e1 - e0
if e1 <= ans or e2 <= ans:
continue
for k in range(i, W+1):
f = T[j][k] - T[j][i]
if e1-f <= ans:
break
ans = max(ans, min(e0, f, e1-f, e2))
for k in range(i, W+1):
f = T[H][k] - e0 - T[j][k] + T[j][i]
if e2-f <= ans:
break
ans = max(ans, min(e0, e1, f, e2-f))
for j in range(H, -1, -1):
e1 = T[j][W] - T[j][i]
if su - e0 - e1 <= ans:
continue
if e1 <= ans:
break
for k in range(j, H+1):
e2 = T[k][W] - T[k][i]
if su-e2-e0 <= ans:
break
ans = max(ans, min(e0, e1, e2-e1, su-e2-e0))
S = rotate(H, W, S)
H, W = W, H
write("%d\n" % ans)
solve()
``` | output | 1 | 54,745 | 23 | 109,491 |
Provide a correct Python 3 solution for this coding contest problem.
Areas on the Cross-Section Diagram
Your task is to simulate a flood damage.
For a given cross-section diagram, reports areas of flooded sections.
<image>
Assume that rain is falling endlessly in the region and the water overflowing from the region is falling in the sea at the both sides. For example, for the above cross-section diagram, the rain will create floods which have areas of 4, 2, 1, 19 and 9 respectively.
output
Report the areas of floods in the following format:
$A$
$k$ $L_1$ $L_2$ ... $L_k$
In the first line, print the total area $A$ of created floods.
In the second line, print the number of floods $k$ and areas $L_i (i = 1, 2, ..., k)$ for each flood from the left side of the cross-section diagram. Print a space character before $L_i$.
Constraints
* $1 \leq$ length of the string $\leq 20,000$
Input
A string, which represents slopes and flatlands by '/', '\' and '_' respectively, is given in a line. For example, the region of the above example is given by a string "\\\///\\_/\/\\\\\\\/_/\\\///__\\\\\\_\\\/_\/_/\".
Examples
Input
\\//
Output
4
1 4
Input
\\///\_/\/\\\\/_/\\///__\\\_\\/_\/_/\
Output
35
5 4 2 1 19 9 | instruction | 0 | 54,756 | 23 | 109,512 |
"Correct Solution:
```
from collections import deque
def marge_ponds(lx, area_of_pond):
global ponds
if ponds and ponds[-1][0] > lx:
return marge_ponds(lx, area_of_pond + ponds.pop()[1])
return area_of_pond
terrains = input().strip()
x, last_x, ponds = 0, deque(), deque()
for terrain in terrains:
if terrain == '\\':
last_x.append(x)
elif terrain == '/':
if last_x:
lx = last_x.pop()
ponds.append((lx, marge_ponds(lx, x - lx)))
x += 1
print(sum(pond[1] for pond in ponds))
ponds.appendleft((0, len(ponds)))
print(' '.join(map(str, [pond[1] for pond in ponds])))
``` | output | 1 | 54,756 | 23 | 109,513 |
Provide a correct Python 3 solution for this coding contest problem.
Areas on the Cross-Section Diagram
Your task is to simulate a flood damage.
For a given cross-section diagram, reports areas of flooded sections.
<image>
Assume that rain is falling endlessly in the region and the water overflowing from the region is falling in the sea at the both sides. For example, for the above cross-section diagram, the rain will create floods which have areas of 4, 2, 1, 19 and 9 respectively.
output
Report the areas of floods in the following format:
$A$
$k$ $L_1$ $L_2$ ... $L_k$
In the first line, print the total area $A$ of created floods.
In the second line, print the number of floods $k$ and areas $L_i (i = 1, 2, ..., k)$ for each flood from the left side of the cross-section diagram. Print a space character before $L_i$.
Constraints
* $1 \leq$ length of the string $\leq 20,000$
Input
A string, which represents slopes and flatlands by '/', '\' and '_' respectively, is given in a line. For example, the region of the above example is given by a string "\\\///\\_/\/\\\\\\\/_/\\\///__\\\\\\_\\\/_\/_/\".
Examples
Input
\\//
Output
4
1 4
Input
\\///\_/\/\\\\/_/\\///__\\\_\\/_\/_/\
Output
35
5 4 2 1 19 9 | instruction | 0 | 54,757 | 23 | 109,514 |
"Correct Solution:
```
n = input()
s1 = []
s2 = []
for i in range(len(n)):
if n[i] == '\\':
s1.append(i)
elif n[i] == '/' and len(s1) > 0:
a = s1.pop(-1)
s2.append([a, i - a])
i = 0
while len(s2) > 1:
if i == len(s2) - 1:
break
elif s2[i][0] > s2[i + 1][0]:
s2[i + 1][1] += s2.pop(i)[1]
i = 0
else:
i += 1
s = []
total = 0
for i in s2:
s.append(str(int(i[1])))
total += int(i[1])
print(total)
if len(s2) == 0:
print('0')
else:
print('{} {}'.format(len(s2), ' '.join(s)))
``` | output | 1 | 54,757 | 23 | 109,515 |
Provide a correct Python 3 solution for this coding contest problem.
Areas on the Cross-Section Diagram
Your task is to simulate a flood damage.
For a given cross-section diagram, reports areas of flooded sections.
<image>
Assume that rain is falling endlessly in the region and the water overflowing from the region is falling in the sea at the both sides. For example, for the above cross-section diagram, the rain will create floods which have areas of 4, 2, 1, 19 and 9 respectively.
output
Report the areas of floods in the following format:
$A$
$k$ $L_1$ $L_2$ ... $L_k$
In the first line, print the total area $A$ of created floods.
In the second line, print the number of floods $k$ and areas $L_i (i = 1, 2, ..., k)$ for each flood from the left side of the cross-section diagram. Print a space character before $L_i$.
Constraints
* $1 \leq$ length of the string $\leq 20,000$
Input
A string, which represents slopes and flatlands by '/', '\' and '_' respectively, is given in a line. For example, the region of the above example is given by a string "\\\///\\_/\/\\\\\\\/_/\\\///__\\\\\\_\\\/_\/_/\".
Examples
Input
\\//
Output
4
1 4
Input
\\///\_/\/\\\\/_/\\///__\\\_\\/_\/_/\
Output
35
5 4 2 1 19 9 | instruction | 0 | 54,758 | 23 | 109,516 |
"Correct Solution:
```
from collections import deque
s = input()
d = deque()
l = deque()
def calc_area(j, i):
return i - j
for i, c in enumerate(s):
if c == "\\":
d.append(i)
if c == "/":
if len(d) == 0:
continue
j = d.pop()
s = calc_area(j, i)
while len(l) > 0:
_j, _i, _s = l.pop()
if j < _j:
s += _s
else:
l.append((_j, _i, _s))
break
l.append((j, i, s))
ans = str(len(l))
sum_area = 0
for j, i, s in l:
ans += " " + str(s)
sum_area += s
print(sum_area)
print(ans)
``` | output | 1 | 54,758 | 23 | 109,517 |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.