message stringlengths 2 44.5k | message_type stringclasses 2 values | message_id int64 0 1 | conversation_id int64 276 109k | cluster float64 23 23 | __index_level_0__ int64 552 217k |
|---|---|---|---|---|---|
Provide tags and a correct Python 3 solution for this coding contest problem.
At a geometry lesson Bob learnt that a triangle is called right-angled if it is nondegenerate and one of its angles is right. Bob decided to draw such a triangle immediately: on a sheet of paper he drew three points with integer coordinates, and joined them with segments of straight lines, then he showed the triangle to Peter. Peter said that Bob's triangle is not right-angled, but is almost right-angled: the triangle itself is not right-angled, but it is possible to move one of the points exactly by distance 1 so, that all the coordinates remain integer, and the triangle become right-angled. Bob asks you to help him and find out if Peter tricks him. By the given coordinates of the triangle you should find out if it is right-angled, almost right-angled, or neither of these.
Input
The first input line contains 6 space-separated integers x1, y1, x2, y2, x3, y3 — coordinates of the triangle's vertices. All the coordinates are integer and don't exceed 100 in absolute value. It's guaranteed that the triangle is nondegenerate, i.e. its total area is not zero.
Output
If the given triangle is right-angled, output RIGHT, if it is almost right-angled, output ALMOST, and if it is neither of these, output NEITHER.
Examples
Input
0 0 2 0 0 1
Output
RIGHT
Input
2 3 4 5 6 6
Output
NEITHER
Input
-1 0 2 0 0 1
Output
ALMOST | instruction | 0 | 25,873 | 23 | 51,746 |
Tags: brute force, geometry
Correct Solution:
```
import sys
from math import *
def minp():
return sys.stdin.readline().strip()
def mint():
return int(minp())
def mints():
return map(int, minp().split())
def right(x1,y1,x2,y2,x3,y3):
x2-=x1
y2-=y1
x3-=x1
y3-=y1
if x2*y3-x3*y2 == 0:
return False
l1 = x2**2+y2**2
l2 = x3**2+y3**2
l3 = (x3-x2)**2+(y3-y2)**2
if l1+l2 == l3 or l2+l3 == l1 or l1+l3 == l2:
return True
return False
x = list(mints())
if right(*x):
print("RIGHT")
exit(0)
for i in range(3):
for dx,dy in (1,0),(-1,0),(0,1),(0,-1):
x[2*i] += dx
x[2*i+1] += dy
if right(*x):
print("ALMOST")
exit(0)
x[2*i] -= dx
x[2*i+1] -= dy
print("NEITHER")
``` | output | 1 | 25,873 | 23 | 51,747 |
Provide tags and a correct Python 3 solution for this coding contest problem.
At a geometry lesson Bob learnt that a triangle is called right-angled if it is nondegenerate and one of its angles is right. Bob decided to draw such a triangle immediately: on a sheet of paper he drew three points with integer coordinates, and joined them with segments of straight lines, then he showed the triangle to Peter. Peter said that Bob's triangle is not right-angled, but is almost right-angled: the triangle itself is not right-angled, but it is possible to move one of the points exactly by distance 1 so, that all the coordinates remain integer, and the triangle become right-angled. Bob asks you to help him and find out if Peter tricks him. By the given coordinates of the triangle you should find out if it is right-angled, almost right-angled, or neither of these.
Input
The first input line contains 6 space-separated integers x1, y1, x2, y2, x3, y3 — coordinates of the triangle's vertices. All the coordinates are integer and don't exceed 100 in absolute value. It's guaranteed that the triangle is nondegenerate, i.e. its total area is not zero.
Output
If the given triangle is right-angled, output RIGHT, if it is almost right-angled, output ALMOST, and if it is neither of these, output NEITHER.
Examples
Input
0 0 2 0 0 1
Output
RIGHT
Input
2 3 4 5 6 6
Output
NEITHER
Input
-1 0 2 0 0 1
Output
ALMOST | instruction | 0 | 25,874 | 23 | 51,748 |
Tags: brute force, geometry
Correct Solution:
```
def distance(x1, y1, x2, y2): #deltas of points. distance between them on Oxy
deltax = x2 - x1
deltay = y2 - y1
return deltax * deltax + deltay * deltay
def trianglech(x1, y1, x2, y2, x3, y3):
a = distance(x1, y1, x2, y2) #distances of catetes
b = distance(x2, y2, x3, y3)
c = distance(x3, y3, x1, y1)
a, b, c = sorted([a, b, c])
if a == 0:
return False
return c == a + b
x1, y1, x2, y2, x3, y3 = [int(x) for x in input().split()]
if trianglech(x1, y1, x2, y2, x3, y3):
print('RIGHT')
exit()
for deltax, deltay in [(1, 0), (-1, 0), (0, 1), (0, -1)]: #error checking. every point has been allocated an error. if differs of right ones = almost or neither
if (trianglech(x1 + deltax, y1 + deltay, x2, y2, x3, y3) or
trianglech(x1, y1, x2 + deltax, y2 + deltay, x3, y3) or
trianglech(x1, y1, x2, y2, x3 + deltax, y3 + deltay)):
print('ALMOST')
exit()
print('NEITHER')
``` | output | 1 | 25,874 | 23 | 51,749 |
Provide tags and a correct Python 3 solution for this coding contest problem.
At a geometry lesson Bob learnt that a triangle is called right-angled if it is nondegenerate and one of its angles is right. Bob decided to draw such a triangle immediately: on a sheet of paper he drew three points with integer coordinates, and joined them with segments of straight lines, then he showed the triangle to Peter. Peter said that Bob's triangle is not right-angled, but is almost right-angled: the triangle itself is not right-angled, but it is possible to move one of the points exactly by distance 1 so, that all the coordinates remain integer, and the triangle become right-angled. Bob asks you to help him and find out if Peter tricks him. By the given coordinates of the triangle you should find out if it is right-angled, almost right-angled, or neither of these.
Input
The first input line contains 6 space-separated integers x1, y1, x2, y2, x3, y3 — coordinates of the triangle's vertices. All the coordinates are integer and don't exceed 100 in absolute value. It's guaranteed that the triangle is nondegenerate, i.e. its total area is not zero.
Output
If the given triangle is right-angled, output RIGHT, if it is almost right-angled, output ALMOST, and if it is neither of these, output NEITHER.
Examples
Input
0 0 2 0 0 1
Output
RIGHT
Input
2 3 4 5 6 6
Output
NEITHER
Input
-1 0 2 0 0 1
Output
ALMOST | instruction | 0 | 25,875 | 23 | 51,750 |
Tags: brute force, geometry
Correct Solution:
```
# python 3
"""
"""
def dist_squared(point_1, point_2):
return pow(point_1[0] - point_2[0], 2) + pow(point_1[1] - point_2[1], 2)
def right_triangle(p12_squared, p23_squared, p13_squared):
if p12_squared == p13_squared + p23_squared or \
p23_squared == p13_squared + p12_squared or \
p13_squared == p12_squared + p23_squared:
return True
else:
return False
def move_by_dist(point, dist_x, dist_y):
return point[0] + dist_x, point[1] + dist_y
def triangle(p_1_x_int, p_1_y_int, p_2_x_int, p_2_y_int, p_3_x_int, p_3_y_int) -> str:
p_1 = (p_1_x_int, p_1_y_int)
p_2 = (p_2_x_int, p_2_y_int)
p_3 = (p_3_x_int, p_3_y_int)
if right_triangle(dist_squared(p_1, p_2), dist_squared(p_2, p_3), dist_squared(p_1, p_3)):
return "RIGHT"
dist_1 = [(1, 0), (-1, 0), (0, 1), (0, -1)]
for each in dist_1:
p_1_new = move_by_dist(p_1, each[0], each[1])
if p_1_new != p_2 and p_1_new != p_3 and right_triangle(
dist_squared(p_1_new, p_2), dist_squared(p_2, p_3), dist_squared(p_1_new, p_3)):
return "ALMOST"
p_2_new = move_by_dist(p_2, each[0], each[1])
if p_2_new != p_1 and p_2_new != p_3 and right_triangle(
dist_squared(p_1, p_2_new), dist_squared(p_2_new, p_3), dist_squared(p_1, p_3)):
return "ALMOST"
p_3_new = move_by_dist(p_3, each[0], each[1])
if p_3_new != p_1 and p_3_new != p_2 and right_triangle(
dist_squared(p_1, p_2), dist_squared(p_2, p_3_new), dist_squared(p_1, p_3_new)):
return "ALMOST"
return "NEITHER"
if __name__ == "__main__":
"""
Inside of this is the test.
Outside is the API
"""
p_1_x, p_1_y, p_2_x, p_2_y, p_3_x, p_3_y = list(map(int, input().split()))
print(triangle(p_1_x, p_1_y, p_2_x, p_2_y, p_3_x, p_3_y))
``` | output | 1 | 25,875 | 23 | 51,751 |
Provide tags and a correct Python 3 solution for this coding contest problem.
At a geometry lesson Bob learnt that a triangle is called right-angled if it is nondegenerate and one of its angles is right. Bob decided to draw such a triangle immediately: on a sheet of paper he drew three points with integer coordinates, and joined them with segments of straight lines, then he showed the triangle to Peter. Peter said that Bob's triangle is not right-angled, but is almost right-angled: the triangle itself is not right-angled, but it is possible to move one of the points exactly by distance 1 so, that all the coordinates remain integer, and the triangle become right-angled. Bob asks you to help him and find out if Peter tricks him. By the given coordinates of the triangle you should find out if it is right-angled, almost right-angled, or neither of these.
Input
The first input line contains 6 space-separated integers x1, y1, x2, y2, x3, y3 — coordinates of the triangle's vertices. All the coordinates are integer and don't exceed 100 in absolute value. It's guaranteed that the triangle is nondegenerate, i.e. its total area is not zero.
Output
If the given triangle is right-angled, output RIGHT, if it is almost right-angled, output ALMOST, and if it is neither of these, output NEITHER.
Examples
Input
0 0 2 0 0 1
Output
RIGHT
Input
2 3 4 5 6 6
Output
NEITHER
Input
-1 0 2 0 0 1
Output
ALMOST | instruction | 0 | 25,876 | 23 | 51,752 |
Tags: brute force, geometry
Correct Solution:
```
x1,y1,x2,y2,x3,y3=map(int,input().split())
def tri(x1,y1,x2,y2,x3,y3):
if (x1==x2 and y1==y2) or (x3==x2 and y3==y2) or (x1==x3 and y1==y3):
return False
if ((x1-x2)*(x3-x2)==-(y1-y2)*(y3-y2)) or ((x2-x1)*(x3-x1)==-(y2-y1)*(y3-y1)) or ((x1-x3)*(x2-x3)==-(y1-y3)*(y2-y3)):
return True
else:
return False
if tri(x1,y1,x2,y2,x3,y3):
print('RIGHT')
else:
if tri(x1-1,y1,x2,y2,x3,y3) or tri(x1+1,y1,x2,y2,x3,y3) or tri(x1,y1-1,x2,y2,x3,y3) or tri(x1,y1+1,x2,y2,x3,y3) or tri(x1,y1,x2-1,y2,x3,y3) or tri(x1,y1,x2+1,y2,x3,y3) or tri(x1,y1,x2,y2-1,x3,y3) or tri(x1,y1,x2,y2+1,x3,y3) or tri(x1,y1,x2,y2,x3-1,y3) or tri(x1,y1,x2,y2,x3+1,y3) or tri(x1,y1,x2,y2,x3,y3+1) or tri(x1,y1,x2,y2,x3,y3-1):
print('ALMOST')
else:
print('NEITHER')
``` | output | 1 | 25,876 | 23 | 51,753 |
Provide tags and a correct Python 3 solution for this coding contest problem.
At a geometry lesson Bob learnt that a triangle is called right-angled if it is nondegenerate and one of its angles is right. Bob decided to draw such a triangle immediately: on a sheet of paper he drew three points with integer coordinates, and joined them with segments of straight lines, then he showed the triangle to Peter. Peter said that Bob's triangle is not right-angled, but is almost right-angled: the triangle itself is not right-angled, but it is possible to move one of the points exactly by distance 1 so, that all the coordinates remain integer, and the triangle become right-angled. Bob asks you to help him and find out if Peter tricks him. By the given coordinates of the triangle you should find out if it is right-angled, almost right-angled, or neither of these.
Input
The first input line contains 6 space-separated integers x1, y1, x2, y2, x3, y3 — coordinates of the triangle's vertices. All the coordinates are integer and don't exceed 100 in absolute value. It's guaranteed that the triangle is nondegenerate, i.e. its total area is not zero.
Output
If the given triangle is right-angled, output RIGHT, if it is almost right-angled, output ALMOST, and if it is neither of these, output NEITHER.
Examples
Input
0 0 2 0 0 1
Output
RIGHT
Input
2 3 4 5 6 6
Output
NEITHER
Input
-1 0 2 0 0 1
Output
ALMOST | instruction | 0 | 25,877 | 23 | 51,754 |
Tags: brute force, geometry
Correct Solution:
```
def check(a1, a2, b1, b2, c1, c2):
x = (a1 - b1) ** 2 + (a2 - b2) ** 2
y = (b1 - c1) ** 2 + (c2 - b2) ** 2
z = (a1 - c1) **2 + (c2 - a2) ** 2
l1 = [x,y,z]
l1.sort()
if l1[0] + l1[1] == l1[2] and x != 0 and y != 0 and z != 0:
return True
else :
return False
a1, a2, b1, b2, c1, c2 = map(int, input().split())
if check(a1,a2,b1,b2,c1,c2):
print("RIGHT")
elif check(a1+1,a2,b1,b2,c1,c2) or check(a1-1,a2,b1,b2,c1,c2):
print("ALMOST")
elif check(a1,a2+1,b1,b2,c1,c2) or check(a1,a2-1,b1,b2,c1,c2):
print("ALMOST")
elif check(a1,a2,b1+1,b2,c1,c2) or check(a1,a2,b1-1,b2,c1,c2):
print("ALMOST")
elif check(a1,a2,b1,b2+1,c1,c2) or check(a1,a2,b1,b2-1,c1,c2):
print("ALMOST")
elif check(a1,a2,b1,b2,c1+1,c2) or check(a1,a2,b1,b2,c1-1,c2):
print("ALMOST")
elif check(a1,a2,b1,b2,c1,c2+1) or check(a1,a2,b1,b2,c1,c2-1):
print("ALMOST")
else :
print("NEITHER")
``` | output | 1 | 25,877 | 23 | 51,755 |
Provide tags and a correct Python 3 solution for this coding contest problem.
At a geometry lesson Bob learnt that a triangle is called right-angled if it is nondegenerate and one of its angles is right. Bob decided to draw such a triangle immediately: on a sheet of paper he drew three points with integer coordinates, and joined them with segments of straight lines, then he showed the triangle to Peter. Peter said that Bob's triangle is not right-angled, but is almost right-angled: the triangle itself is not right-angled, but it is possible to move one of the points exactly by distance 1 so, that all the coordinates remain integer, and the triangle become right-angled. Bob asks you to help him and find out if Peter tricks him. By the given coordinates of the triangle you should find out if it is right-angled, almost right-angled, or neither of these.
Input
The first input line contains 6 space-separated integers x1, y1, x2, y2, x3, y3 — coordinates of the triangle's vertices. All the coordinates are integer and don't exceed 100 in absolute value. It's guaranteed that the triangle is nondegenerate, i.e. its total area is not zero.
Output
If the given triangle is right-angled, output RIGHT, if it is almost right-angled, output ALMOST, and if it is neither of these, output NEITHER.
Examples
Input
0 0 2 0 0 1
Output
RIGHT
Input
2 3 4 5 6 6
Output
NEITHER
Input
-1 0 2 0 0 1
Output
ALMOST | instruction | 0 | 25,878 | 23 | 51,756 |
Tags: brute force, geometry
Correct Solution:
```
class point:
def __init__(self, x=0, y=0):
self.x = x
self.y = y
def trans(self, d):
return point(self.x + d[0], self.y + d[1])
def cross(a, b, c): return (a.x-c.x) * (b.y-c.y) - (a.y-c.y) * (b.x-c.x)
def dot(a, b, c): return (a.x-c.x) * (b.x-c.x) + (a.y-c.y) * (b.y-c.y)
def isRight(a, b, c):
if cross(a, b, c) == 0: return False
return dot(a, b, c) == 0 or dot(a, c, b) == 0 or dot(b, c, a) == 0
d = ((0, 1), (0, -1), (1, 0), (-1, 0))
def solve(a, b, c):
if isRight(a, b, c): return 'RIGHT'
for i in d:
if isRight(a.trans(i), b, c): return 'ALMOST'
for i in d:
if isRight(a, b.trans(i), c): return 'ALMOST'
for i in d:
if isRight(a, b, c.trans(i)): return 'ALMOST'
return 'NEITHER'
x1, y1, x2, y2, x3, y3 = map(int, input().split())
print(solve(point(x1, y1), point(x2, y2), point(x3, y3)))
``` | output | 1 | 25,878 | 23 | 51,757 |
Provide tags and a correct Python 3 solution for this coding contest problem.
At a geometry lesson Bob learnt that a triangle is called right-angled if it is nondegenerate and one of its angles is right. Bob decided to draw such a triangle immediately: on a sheet of paper he drew three points with integer coordinates, and joined them with segments of straight lines, then he showed the triangle to Peter. Peter said that Bob's triangle is not right-angled, but is almost right-angled: the triangle itself is not right-angled, but it is possible to move one of the points exactly by distance 1 so, that all the coordinates remain integer, and the triangle become right-angled. Bob asks you to help him and find out if Peter tricks him. By the given coordinates of the triangle you should find out if it is right-angled, almost right-angled, or neither of these.
Input
The first input line contains 6 space-separated integers x1, y1, x2, y2, x3, y3 — coordinates of the triangle's vertices. All the coordinates are integer and don't exceed 100 in absolute value. It's guaranteed that the triangle is nondegenerate, i.e. its total area is not zero.
Output
If the given triangle is right-angled, output RIGHT, if it is almost right-angled, output ALMOST, and if it is neither of these, output NEITHER.
Examples
Input
0 0 2 0 0 1
Output
RIGHT
Input
2 3 4 5 6 6
Output
NEITHER
Input
-1 0 2 0 0 1
Output
ALMOST | instruction | 0 | 25,879 | 23 | 51,758 |
Tags: brute force, geometry
Correct Solution:
```
from math import sqrt
def distance(a,b):
delta_x=a[0]-b[0]
delta_y=a[1]-b[1]
return sqrt( delta_x**2+delta_y**2 )
a,b,c=0,0,0
def check(liste):
p1,p2,p3=liste
a,b,c=distance(p1,p2),distance(p2,p3),distance(p1,p3)
a,b,c=sorted([a,b,c])
if a+b<=c or abs((a**2+b**2-c**2)*1e8)//1!=0:
return False
else:
return True
a,b,c,d,e,f=[int(element) for element in input().split(" ")]
p=[(a,b),(c,d),(e,f)]
if check(p):
print("RIGHT")
else:
bool=True
for i in range(3):
for delta in [(0,1),(1,0),(-1,0),(0,-1)]:
x,y=p[i][0]+delta[0],p[i][1]+delta[1]
test=[(x,y)]
for j in range(3):
if j!=i:
test.append(p[j])
if check(test) and bool:
print("ALMOST")
bool=False
if bool:
print("NEITHER")
``` | output | 1 | 25,879 | 23 | 51,759 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
At a geometry lesson Bob learnt that a triangle is called right-angled if it is nondegenerate and one of its angles is right. Bob decided to draw such a triangle immediately: on a sheet of paper he drew three points with integer coordinates, and joined them with segments of straight lines, then he showed the triangle to Peter. Peter said that Bob's triangle is not right-angled, but is almost right-angled: the triangle itself is not right-angled, but it is possible to move one of the points exactly by distance 1 so, that all the coordinates remain integer, and the triangle become right-angled. Bob asks you to help him and find out if Peter tricks him. By the given coordinates of the triangle you should find out if it is right-angled, almost right-angled, or neither of these.
Input
The first input line contains 6 space-separated integers x1, y1, x2, y2, x3, y3 — coordinates of the triangle's vertices. All the coordinates are integer and don't exceed 100 in absolute value. It's guaranteed that the triangle is nondegenerate, i.e. its total area is not zero.
Output
If the given triangle is right-angled, output RIGHT, if it is almost right-angled, output ALMOST, and if it is neither of these, output NEITHER.
Examples
Input
0 0 2 0 0 1
Output
RIGHT
Input
2 3 4 5 6 6
Output
NEITHER
Input
-1 0 2 0 0 1
Output
ALMOST
Submitted Solution:
```
def isRight( a ):
x1,y1,x2,y2,x3,y3 = a
if (x1==x2 and y1==y2) or (x1==x3 and y1==y3) or (x2==x3 and y2==y3):
return False
A = (y2-y1)**2 + (x2-x1)**2
B = (y3-y1)**2 + (x3-x1)**2
C = (y3-y2)**2 + (x3-x2)**2
check = [A,B,C]
check.sort()
return (check[0]+check[1] == check[2])
a = [int(x) for x in input().split()]
if isRight(a):
print("RIGHT")
else:
isOk = False
for i in range(0,6):
a[i] += 1
isOk = isOk or isRight(a)
a[i] -= 1
for i in range(0,6):
a[i] += -1
isOk = isOk or isRight(a)
a[i] -= -1
if(isOk):
print("ALMOST")
else:
print("NEITHER")
``` | instruction | 0 | 25,880 | 23 | 51,760 |
Yes | output | 1 | 25,880 | 23 | 51,761 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
At a geometry lesson Bob learnt that a triangle is called right-angled if it is nondegenerate and one of its angles is right. Bob decided to draw such a triangle immediately: on a sheet of paper he drew three points with integer coordinates, and joined them with segments of straight lines, then he showed the triangle to Peter. Peter said that Bob's triangle is not right-angled, but is almost right-angled: the triangle itself is not right-angled, but it is possible to move one of the points exactly by distance 1 so, that all the coordinates remain integer, and the triangle become right-angled. Bob asks you to help him and find out if Peter tricks him. By the given coordinates of the triangle you should find out if it is right-angled, almost right-angled, or neither of these.
Input
The first input line contains 6 space-separated integers x1, y1, x2, y2, x3, y3 — coordinates of the triangle's vertices. All the coordinates are integer and don't exceed 100 in absolute value. It's guaranteed that the triangle is nondegenerate, i.e. its total area is not zero.
Output
If the given triangle is right-angled, output RIGHT, if it is almost right-angled, output ALMOST, and if it is neither of these, output NEITHER.
Examples
Input
0 0 2 0 0 1
Output
RIGHT
Input
2 3 4 5 6 6
Output
NEITHER
Input
-1 0 2 0 0 1
Output
ALMOST
Submitted Solution:
```
#function checks if coordinates of vertices belong to the right-angle triangle
def triangle(x1, y1, x2, y2, x3, y3):
a2 = (x1 - x2)**2+(y1-y2)**2 #first side^2
b2 = (x1 - x3)**2+(y1-y3)**2 #second side^2
c2 = (x3 - x2)**2+(y3-y2)**2 #third side^2
return ((a2+b2 == c2 or c2+b2 == a2 or a2+c2 == b2) and (a2*b2*c2 != 0)) #if the sum of squares of legs is equal to the hypotenuse^2, then it is a right-angle triangle
x1, y1, x2, y2, x3, y3 = map(int,input().split())
if ( triangle(x1, y1, x2, y2, x3, y3)):
print("RIGHT") #if it is exactly right-angle triangle
elif( triangle(x1+1, y1, x2, y2, x3, y3) or triangle(x1-1, y1, x2, y2, x3, y3) or triangle(x1, y1+1, x2, y2, x3, y3) or triangle(x1, y1-1, x2, y2, x3, y3) or triangle(x1, y1, x2+1, y2, x3, y3) or triangle(x1, y1, x2-1, y2, x3, y3) or triangle(x1, y1, x2, y2+1, x3, y3) or triangle(x1, y1, x2, y2-1, x3, y3) or triangle(x1, y1, x2, y2, x3+1, y3) or triangle(x1, y1, x2, y2, x3-1, y3) or triangle(x1, y1, x2, y2, x3, y3+1) or triangle(x1, y1, x2, y2, x3, y3-1)):
print("ALMOST") #if it is necessary to change one coordinate with 1 to get right-angle triangle
else:
print("NEITHER") #if it is not a right-angle triangle
``` | instruction | 0 | 25,881 | 23 | 51,762 |
Yes | output | 1 | 25,881 | 23 | 51,763 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
At a geometry lesson Bob learnt that a triangle is called right-angled if it is nondegenerate and one of its angles is right. Bob decided to draw such a triangle immediately: on a sheet of paper he drew three points with integer coordinates, and joined them with segments of straight lines, then he showed the triangle to Peter. Peter said that Bob's triangle is not right-angled, but is almost right-angled: the triangle itself is not right-angled, but it is possible to move one of the points exactly by distance 1 so, that all the coordinates remain integer, and the triangle become right-angled. Bob asks you to help him and find out if Peter tricks him. By the given coordinates of the triangle you should find out if it is right-angled, almost right-angled, or neither of these.
Input
The first input line contains 6 space-separated integers x1, y1, x2, y2, x3, y3 — coordinates of the triangle's vertices. All the coordinates are integer and don't exceed 100 in absolute value. It's guaranteed that the triangle is nondegenerate, i.e. its total area is not zero.
Output
If the given triangle is right-angled, output RIGHT, if it is almost right-angled, output ALMOST, and if it is neither of these, output NEITHER.
Examples
Input
0 0 2 0 0 1
Output
RIGHT
Input
2 3 4 5 6 6
Output
NEITHER
Input
-1 0 2 0 0 1
Output
ALMOST
Submitted Solution:
```
import math
__author__ = 'Obriel Muga'
def distance(A,B):
return math.sqrt((A[1] - B[1])**2 + (A[0] - B[0])**2)
def notDegenerated(A,B,C):
return (A + B > C and A + C > B and B + C > A)
def rightAngle(A,B,C):
statement1 = math.sqrt(round(A**2,5) + round(B**2,5)) == C
statement2 = math.sqrt(round(A**2,5) + round(C**2,5)) == B
statement3 = math.sqrt(round(C**2,5) + round(B**2,5))== A
return (statement1 or statement2 or statement3)
if __name__ == '__main__':
diccionario = dict()
x1,y1,x2,y2,x3,y3 = list(map(int,input().strip().split()))
A = (x1,y1)
B = (x2,y2)
C = (x3,y3)
diccionario['A'] = A
diccionario['B'] = B
diccionario['C'] = C
AB = distance(A,B)
AC = distance(A,C)
BC = distance(B,C)
result = False
if (rightAngle(AB,AC,BC)):
print("RIGHT")
else:
for llave,valor in diccionario.items():
if (llave == 'A'):
a0 = (valor[0] + 1 , valor[1])
a1 = (valor[0], valor[1] + 1)
a2 = (valor[0] -1 , valor[1])
a3 = (valor[0] , valor[1] - 1)
AB0 = distance(a0,B)
AB1 = distance(a1,B)
AB2 = distance(a2,B)
AB3 = distance(a3,B)
AC0 = distance(a0,C)
AC1 = distance(a1,C)
AC2 = distance(a2,C)
AC3 = distance(a3,C)
if (notDegenerated(AB0,AC0,BC) and rightAngle(AB0,AC0,BC)):
result = True
print("ALMOST")
break
elif (notDegenerated(AB1,AC1,BC) and rightAngle(AB1,AC1,BC)):
result = True
print("ALMOST")
break
elif (notDegenerated(AB2,AC2,BC) and rightAngle(AB2,AC2,BC)):
result = True
print("ALMOST")
break
elif (notDegenerated(AB3,AC3,BC) and rightAngle(AB3,AC3,BC)):
result = True
print("ALMOST")
break
elif (llave == 'B'):
b0 = (valor[0] + 1, valor[1])
b1 = (valor[0], valor[1] + 1)
b2 = (valor[0] -1 , valor[1])
b3 = (valor[0] , valor[1] - 1)
AB0 = distance(A,b0)
AB1 = distance(A,b1)
AB2 = distance(A,b2)
AB3 = distance(A,b3)
BC0 = distance(b0,C)
BC1 = distance(b1,C)
BC2 = distance(b2,C)
BC3 = distance(b3,C)
if (notDegenerated(AB0,AC,BC0) and rightAngle(AB0,AC,BC0)):
result = True
print("ALMOST")
break
elif (notDegenerated(AB1,AC,BC1) and rightAngle(AB1,AC,BC1)):
result = True
print("ALMOST")
break
elif (notDegenerated(AB2,AC,BC2) and rightAngle(AB2,AC,BC2)):
result = True
print("ALMOST")
break
elif (notDegenerated(AB3,AC,BC3) and rightAngle(AB3,AC,BC3)):
result = True
print("ALMOST")
break
elif (llave == 'C'):
c0 = (valor[0] + 1, valor[1])
c1 = (valor[0], valor[1] + 1)
c2 = (valor[0] -1 , valor[1])
c3 = (valor[0] , valor[1] - 1)
AC0 = distance(A,c0)
AC1 = distance(A,c1)
AC2 = distance(A,c2)
AC3 = distance(A,c3)
BC0 = distance(B,c0)
BC1 = distance(B,c1)
BC2 = distance(B,c2)
BC3 = distance(B,c3)
if (notDegenerated(AB,AC0,BC0) and rightAngle(AB,AC0,BC0)):
result = True
print("ALMOST")
break
elif (notDegenerated(AB,AC1,BC1) and rightAngle(AB,AC1,BC1)):
result = True
print("ALMOST")
break
elif (notDegenerated(AB,AC2,BC2) and rightAngle(AB,AC2,BC2)):
result = True
print("ALMOST")
break
elif (notDegenerated(AB,AC3,BC3) and rightAngle(AB,AC3,BC3)):
result = True
print("ALMOST")
break
if (not result):
print("NEITHER")
``` | instruction | 0 | 25,882 | 23 | 51,764 |
Yes | output | 1 | 25,882 | 23 | 51,765 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
At a geometry lesson Bob learnt that a triangle is called right-angled if it is nondegenerate and one of its angles is right. Bob decided to draw such a triangle immediately: on a sheet of paper he drew three points with integer coordinates, and joined them with segments of straight lines, then he showed the triangle to Peter. Peter said that Bob's triangle is not right-angled, but is almost right-angled: the triangle itself is not right-angled, but it is possible to move one of the points exactly by distance 1 so, that all the coordinates remain integer, and the triangle become right-angled. Bob asks you to help him and find out if Peter tricks him. By the given coordinates of the triangle you should find out if it is right-angled, almost right-angled, or neither of these.
Input
The first input line contains 6 space-separated integers x1, y1, x2, y2, x3, y3 — coordinates of the triangle's vertices. All the coordinates are integer and don't exceed 100 in absolute value. It's guaranteed that the triangle is nondegenerate, i.e. its total area is not zero.
Output
If the given triangle is right-angled, output RIGHT, if it is almost right-angled, output ALMOST, and if it is neither of these, output NEITHER.
Examples
Input
0 0 2 0 0 1
Output
RIGHT
Input
2 3 4 5 6 6
Output
NEITHER
Input
-1 0 2 0 0 1
Output
ALMOST
Submitted Solution:
```
import math
"""
#include <cstdio>
#include <iostream>
#include <algorithm>
bool isRight(int *c){
int sides[3] = {0};
sides[0] = (c[4] - c[2]) * (c[4] - c[2]) + (c[5] - c[3])* (c[5] - c[3]);
sides[1] = (c[4] - c[0]) * (c[4] - c[0]) + (c[5] - c[1])* (c[5] - c[1]);
sides[2] = (c[2] - c[0]) * (c[2] - c[0]) + (c[3] - c[1])* (c[3] - c[1]);
std::sort(sides, sides + 3);
if(sides[0] > 0 && sides[2] == sides[0] + sides[1]){return 1;}
else{return 0;}
}
int main(){
int points[6] = {0};
for(int k = 0; k < 6; k++){scanf("%d", points + k);}
std::string output = "NEITHER";
if(isRight(points)){output = "RIGHT";}
else{
for(int k = 0; k < 6; k++){
++points[k]; if(isRight(points)){output = "ALMOST"; break;}
points[k] -= 2; if(isRight(points)){output = "ALMOST"; break;}
++points[k];
}
}
std::cout << output << std::endl;
return 0;
}
"""
def distancia_euclidiana(x, y):
lados = []
lados.append(math.pow(x[0] - x[1], 2) + math.pow(y[0] - y[1], 2))
lados.append(math.pow(x[0] - x[2], 2) + math.pow(y[0] - y[2], 2))
lados.append(math.pow(x[1] - x[2], 2) + math.pow(y[1] - y[2], 2))
return sorted(lados)
def is_right(pontos):
distancias = distancia_euclidiana((pontos[0], pontos[2], pontos[4]), (pontos[1], pontos[3], pontos[5]))
#return math.pow(distancias[2], 2) == math.pow(distancias[0], 2) + math.pow(distancias[1], 2)
return distancias[0] > 0 and distancias[2] == distancias[1] + distancias[0]
pontos = [int(i) for i in input().split()]
resultado = 'NEITHER'
if is_right(pontos):
resultado = 'RIGHT'
else:
for i in range(0, 6):
pontos[i] += 1
if is_right(pontos):
resultado = 'ALMOST'
break
pontos[i] -= 2
if is_right(pontos):
resultado = 'ALMOST'
break
pontos[i] += 1
print(resultado)
``` | instruction | 0 | 25,883 | 23 | 51,766 |
Yes | output | 1 | 25,883 | 23 | 51,767 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
At a geometry lesson Bob learnt that a triangle is called right-angled if it is nondegenerate and one of its angles is right. Bob decided to draw such a triangle immediately: on a sheet of paper he drew three points with integer coordinates, and joined them with segments of straight lines, then he showed the triangle to Peter. Peter said that Bob's triangle is not right-angled, but is almost right-angled: the triangle itself is not right-angled, but it is possible to move one of the points exactly by distance 1 so, that all the coordinates remain integer, and the triangle become right-angled. Bob asks you to help him and find out if Peter tricks him. By the given coordinates of the triangle you should find out if it is right-angled, almost right-angled, or neither of these.
Input
The first input line contains 6 space-separated integers x1, y1, x2, y2, x3, y3 — coordinates of the triangle's vertices. All the coordinates are integer and don't exceed 100 in absolute value. It's guaranteed that the triangle is nondegenerate, i.e. its total area is not zero.
Output
If the given triangle is right-angled, output RIGHT, if it is almost right-angled, output ALMOST, and if it is neither of these, output NEITHER.
Examples
Input
0 0 2 0 0 1
Output
RIGHT
Input
2 3 4 5 6 6
Output
NEITHER
Input
-1 0 2 0 0 1
Output
ALMOST
Submitted Solution:
```
import math
#get the input
xA,yA,xB,yB,xC,yC = map(int, input().split())
def getEdges(n=[0]*3):
#use Pitagorian Theorem to find the distance between 2 points
#this distances are the edges of the triangle
AB = math.sqrt((xA + n[0] - (xB + n[1]))**2 + (yA - yB)**2)
BC = math.sqrt((xB + n[1] - (xC + n[2]))**2 + (yB - yC)**2)
CA = math.sqrt((xC + n[2] - (xA + n[0]))**2 + (yC - yA)**2)
#sort edges in increasing order, because we need to know which one is hypotenuse
edges = [AB,BC,CA]
edges.sort()
return edges
def Triangle(hypotenuse,cat1,cat2):
#if the Pitagorian Theorem is satisfied, then we have a RIGHT triangle
#we do this trunc because of error introduced by computer arithmetic
if math.trunc(hypotenuse*100000)/100000 == math.trunc(math.sqrt(cat1**2 + cat2**2)*100000)/100000:
return True
def main():
#get edges for initial input
edges = getEdges()
#check if is right triangle
isTriangle = Triangle(edges[2],edges[1],edges[0])
if isTriangle == True:
print('RIGHT')
return
#if not check if it is almost
else:
#by adding one to each x coordinate and check if is a triangle
for i in range(3):
almostAdd = [0]*3
almostAdd[i] = 1
edges = getEdges(almostAdd)
almost = Triangle(edges[2],edges[1],edges[0])
#if is a triangle print ALMOST
if almost:
print('ALMOST')
return
#If none of the above returned, print NEITHER
print('NEITHER')
return
main()
``` | instruction | 0 | 25,884 | 23 | 51,768 |
No | output | 1 | 25,884 | 23 | 51,769 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
At a geometry lesson Bob learnt that a triangle is called right-angled if it is nondegenerate and one of its angles is right. Bob decided to draw such a triangle immediately: on a sheet of paper he drew three points with integer coordinates, and joined them with segments of straight lines, then he showed the triangle to Peter. Peter said that Bob's triangle is not right-angled, but is almost right-angled: the triangle itself is not right-angled, but it is possible to move one of the points exactly by distance 1 so, that all the coordinates remain integer, and the triangle become right-angled. Bob asks you to help him and find out if Peter tricks him. By the given coordinates of the triangle you should find out if it is right-angled, almost right-angled, or neither of these.
Input
The first input line contains 6 space-separated integers x1, y1, x2, y2, x3, y3 — coordinates of the triangle's vertices. All the coordinates are integer and don't exceed 100 in absolute value. It's guaranteed that the triangle is nondegenerate, i.e. its total area is not zero.
Output
If the given triangle is right-angled, output RIGHT, if it is almost right-angled, output ALMOST, and if it is neither of these, output NEITHER.
Examples
Input
0 0 2 0 0 1
Output
RIGHT
Input
2 3 4 5 6 6
Output
NEITHER
Input
-1 0 2 0 0 1
Output
ALMOST
Submitted Solution:
```
import math
__author__ = 'Obriel Muga'
def distance(A,B):
return math.sqrt((A[1] - B[1])**2 + (A[0] - B[0])**2)
def notDegenerated(A,B,C):
return (A + B > C and A + C > B and B + C > A)
def rightAngle(A,B,C):
statement1 = (math.sqrt(A**2 + B**2) - C < 5e-5)
statement2 = (math.sqrt(A**2 + C**2) - B < 5e-5)
statement3 = (math.sqrt(C**2 + B**2) - A < 5e-5)
return (statement1 or statement2 or statement3)
if __name__ == '__main__':
diccionario = dict()
x1,y1,x2,y2,x3,y3 = list(map(int,input().strip().split()))
A = (x1,y1)
B = (x2,y2)
C = (x3,y3)
diccionario['A'] = A
diccionario['B'] = B
diccionario['C'] = C
AB = distance(A,B)
AC = distance(A,C)
BC = distance(B,C)
result = False
if (rightAngle(AB,AC,BC)):
print("RIGHT")
else:
for llave,valor in diccionario.items():
if (llave == 'A'):
a0 = (valor[0] + 1 , valor[1])
a1 = (valor[0], valor[1] + 1)
a2 = (valor[0] -1 , valor[1])
a3 = (valor[0] , valor[1] - 1)
AB0 = distance(a0,B)
AB1 = distance(a1,B)
AB2 = distance(a2,B)
AB3 = distance(a3,B)
AC0 = distance(a0,C)
AC1 = distance(a1,C)
AC2 = distance(a2,C)
AC3 = distance(a3,C)
if (notDegenerated(AB0,AC0,BC) and rightAngle(AB0,AC0,BC)):
result = True
print("ALMOST")
break
elif (notDegenerated(AB1,AC1,BC) and rightAngle(AB1,AC1,BC)):
result = True
print("ALMOST")
break
elif (notDegenerated(AB2,AC2,BC) and rightAngle(AB2,AC2,BC)):
result = True
print("ALMOST")
break
elif (notDegenerated(AB3,AC3,BC) and rightAngle(AB3,AC3,BC)):
result = True
print("ALMOST")
break
elif (llave == 'B'):
b0 = (valor[0] + 1, valor[1])
b1 = (valor[0], valor[1] + 1)
b2 = (valor[0] -1 , valor[1])
b3 = (valor[0] , valor[1] - 1)
AB0 = distance(A,b0)
AB1 = distance(A,b1)
AB2 = distance(A,b2)
AB3 = distance(A,b3)
BC0 = distance(b0,C)
BC1 = distance(b1,C)
BC2 = distance(b2,C)
BC3 = distance(b3,C)
if (notDegenerated(AB0,AC,BC0) and rightAngle(AB0,AC,BC0)):
result = True
print("ALMOST")
break
elif (notDegenerated(AB1,AC,BC1) and rightAngle(AB1,AC,BC1)):
result = True
print("ALMOST")
break
elif (notDegenerated(AB2,AC,BC2) and rightAngle(AB2,AC,BC2)):
result = True
print("ALMOST")
break
elif (notDegenerated(AB3,AC,BC3) and rightAngle(AB3,AC,BC3)):
result = True
print("ALMOST")
break
elif (llave == 'C'):
c0 = (valor[0] + 1, valor[1])
c1 = (valor[0], valor[1] + 1)
c2 = (valor[0] -1 , valor[1])
c3 = (valor[0] , valor[1] - 1)
AC0 = distance(A,c0)
AC1 = distance(A,c1)
AC2 = distance(A,c2)
AC3 = distance(A,c3)
BC0 = distance(B,c0)
BC1 = distance(B,c1)
BC2 = distance(B,c2)
BC3 = distance(B,c3)
if (notDegenerated(AB,AC0,BC0) and rightAngle(AB,AC0,BC0)):
result = True
print("ALMOST")
break
elif (notDegenerated(AB,AC1,BC1) and rightAngle(AB,AC1,BC1)):
result = True
print("ALMOST")
break
elif (notDegenerated(AB,AC2,BC2) and rightAngle(AB,AC2,BC2)):
result = True
print("ALMOST")
break
elif (notDegenerated(AB,AC3,BC3) and rightAngle(AB,AC3,BC3)):
result = True
print("ALMOST")
break
if (not result):
print("NEITHER")
``` | instruction | 0 | 25,885 | 23 | 51,770 |
No | output | 1 | 25,885 | 23 | 51,771 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
At a geometry lesson Bob learnt that a triangle is called right-angled if it is nondegenerate and one of its angles is right. Bob decided to draw such a triangle immediately: on a sheet of paper he drew three points with integer coordinates, and joined them with segments of straight lines, then he showed the triangle to Peter. Peter said that Bob's triangle is not right-angled, but is almost right-angled: the triangle itself is not right-angled, but it is possible to move one of the points exactly by distance 1 so, that all the coordinates remain integer, and the triangle become right-angled. Bob asks you to help him and find out if Peter tricks him. By the given coordinates of the triangle you should find out if it is right-angled, almost right-angled, or neither of these.
Input
The first input line contains 6 space-separated integers x1, y1, x2, y2, x3, y3 — coordinates of the triangle's vertices. All the coordinates are integer and don't exceed 100 in absolute value. It's guaranteed that the triangle is nondegenerate, i.e. its total area is not zero.
Output
If the given triangle is right-angled, output RIGHT, if it is almost right-angled, output ALMOST, and if it is neither of these, output NEITHER.
Examples
Input
0 0 2 0 0 1
Output
RIGHT
Input
2 3 4 5 6 6
Output
NEITHER
Input
-1 0 2 0 0 1
Output
ALMOST
Submitted Solution:
```
def f(x1,y1,x2,y2,x3,y3):
d1=(x1-x2)**2+(y1-y2)**2
d2=(x2-x3)**2+(y2-y3)**2
d3=(x3-x1)**2+(y3-y1)**2
l=[d1,d2,d3]
l.sort()
if(l[0]+l[1]==l[2]):
return True
else:
return False
x1,y1,x2,y2,x3,y3=map(int, input().split())
if(f(x1,y1,x2,y2,x3,y3)):
print('RIGHT')
elif(f(x1-1,y1,x2,y2,x3,y3) or f(x1,y1-1,x2,y2,x3,y3) or f(x1,y1,x2-1,y2,x3,y3) or f(x1,y1,x2,y2-1,x3,y3) or f(x1,y1,x2,y2,x3-1,y3) or f(x1,y1,x2,y2,x3,y3-1)):
print('ALMOST')
elif(f(x1+1,y1,x2,y2,x3,y3) or f(x1,y1+1,x2,y2,x3,y3) or f(x1,y1,x2+1,y2,x3,y3) or f(x1,y1,x2,y2+1,x3,y3) or f(x1,y1,x2,y2,x3+1,y3) or f(x1,y1,x2,y2,x3,y3+1)):
print('ALMOST')
else:
print('NEITHER')
``` | instruction | 0 | 25,886 | 23 | 51,772 |
No | output | 1 | 25,886 | 23 | 51,773 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
At a geometry lesson Bob learnt that a triangle is called right-angled if it is nondegenerate and one of its angles is right. Bob decided to draw such a triangle immediately: on a sheet of paper he drew three points with integer coordinates, and joined them with segments of straight lines, then he showed the triangle to Peter. Peter said that Bob's triangle is not right-angled, but is almost right-angled: the triangle itself is not right-angled, but it is possible to move one of the points exactly by distance 1 so, that all the coordinates remain integer, and the triangle become right-angled. Bob asks you to help him and find out if Peter tricks him. By the given coordinates of the triangle you should find out if it is right-angled, almost right-angled, or neither of these.
Input
The first input line contains 6 space-separated integers x1, y1, x2, y2, x3, y3 — coordinates of the triangle's vertices. All the coordinates are integer and don't exceed 100 in absolute value. It's guaranteed that the triangle is nondegenerate, i.e. its total area is not zero.
Output
If the given triangle is right-angled, output RIGHT, if it is almost right-angled, output ALMOST, and if it is neither of these, output NEITHER.
Examples
Input
0 0 2 0 0 1
Output
RIGHT
Input
2 3 4 5 6 6
Output
NEITHER
Input
-1 0 2 0 0 1
Output
ALMOST
Submitted Solution:
```
def scm(x1, y1, x2, y2, x3, y3):
return (x2 - x1) * (x3 - x1) + (y2 - y1) * (y3 - y1)
def scma(a):
return (a[1] - a[0]) * (a[2] - a[0]) + (a[4] - a[3]) * (a[5] - a[3])
pair = [1, -2, 1]
f = False
p = [int(i) for i in input().split()]
if scma(p) == 0:
print('RIGHT')
else:
for i in range(6):
for j in pair:
p[i] += j
if scma(p) == 0:
f = True
if f:
print('ALMOST')
else:
print('NEITHER')
``` | instruction | 0 | 25,887 | 23 | 51,774 |
No | output | 1 | 25,887 | 23 | 51,775 |
Provide tags and a correct Python 3 solution for this coding contest problem.
You are given a rectangular field of n × m cells. Each cell is either empty or impassable (contains an obstacle). Empty cells are marked with '.', impassable cells are marked with '*'. Let's call two empty cells adjacent if they share a side.
Let's call a connected component any non-extendible set of cells such that any two of them are connected by the path of adjacent cells. It is a typical well-known definition of a connected component.
For each impassable cell (x, y) imagine that it is an empty cell (all other cells remain unchanged) and find the size (the number of cells) of the connected component which contains (x, y). You should do it for each impassable cell independently.
The answer should be printed as a matrix with n rows and m columns. The j-th symbol of the i-th row should be "." if the cell is empty at the start. Otherwise the j-th symbol of the i-th row should contain the only digit —- the answer modulo 10. The matrix should be printed without any spaces.
To make your output faster it is recommended to build the output as an array of n strings having length m and print it as a sequence of lines. It will be much faster than writing character-by-character.
As input/output can reach huge size it is recommended to use fast input/output methods: for example, prefer to use scanf/printf instead of cin/cout in C++, prefer to use BufferedReader/PrintWriter instead of Scanner/System.out in Java.
Input
The first line contains two integers n, m (1 ≤ n, m ≤ 1000) — the number of rows and columns in the field.
Each of the next n lines contains m symbols: "." for empty cells, "*" for impassable cells.
Output
Print the answer as a matrix as described above. See the examples to precise the format of the output.
Examples
Input
3 3
*.*
.*.
*.*
Output
3.3
.5.
3.3
Input
4 5
**..*
..***
.*.*.
*.*.*
Output
46..3
..732
.6.4.
5.4.3
Note
In first example, if we imagine that the central cell is empty then it will be included to component of size 5 (cross). If any of the corner cell will be empty then it will be included to component of size 3 (corner). | instruction | 0 | 26,044 | 23 | 52,088 |
Tags: dfs and similar
Correct Solution:
```
#### IMPORTANT LIBRARY ####
############################
### DO NOT USE import random --> 250ms to load the library
############################
### In case of extra libraries: https://github.com/cheran-senthil/PyRival
######################
####### IMPORT #######
######################
from functools import cmp_to_key
from collections import deque, Counter
from heapq import heappush, heappop
from math import log, ceil
######################
#### STANDARD I/O ####
######################
import sys
import os
from io import BytesIO, IOBase
BUFSIZE = 8192
class FastIO(IOBase):
newlines = 0
def __init__(self, file):
self._fd = file.fileno()
self.buffer = BytesIO()
self.writable = "x" in file.mode or "r" not in file.mode
self.write = self.buffer.write if self.writable else None
def read(self):
while True:
b = os.read(self._fd, max(os.fstat(self._fd).st_size, BUFSIZE))
if not b:
break
ptr = self.buffer.tell()
self.buffer.seek(0, 2), self.buffer.write(b), self.buffer.seek(ptr)
self.newlines = 0
return self.buffer.read()
def readline(self):
while self.newlines == 0:
b = os.read(self._fd, max(os.fstat(self._fd).st_size, BUFSIZE))
self.newlines = b.count(b"\n") + (not b)
ptr = self.buffer.tell()
self.buffer.seek(0, 2), self.buffer.write(b), self.buffer.seek(ptr)
self.newlines -= 1
return self.buffer.readline()
def flush(self):
if self.writable:
os.write(self._fd, self.buffer.getvalue())
self.buffer.truncate(0), self.buffer.seek(0)
class IOWrapper(IOBase):
def __init__(self, file):
self.buffer = FastIO(file)
self.flush = self.buffer.flush
self.writable = self.buffer.writable
self.write = lambda s: self.buffer.write(s.encode("ascii"))
self.read = lambda: self.buffer.read().decode("ascii")
self.readline = lambda: self.buffer.readline().decode("ascii")
if sys.version_info[0] < 3:
sys.stdin, sys.stdout = FastIO(sys.stdin), FastIO(sys.stdout)
else:
sys.stdin, sys.stdout = IOWrapper(sys.stdin), IOWrapper(sys.stdout)
def print(*args, **kwargs):
sep, file = kwargs.pop("sep", " "), kwargs.pop("file", sys.stdout)
at_start = True
for x in args:
if not at_start:
file.write(sep)
file.write(str(x))
at_start = False
file.write(kwargs.pop("end", "\n"))
if kwargs.pop("flush", False):
file.flush()
def inp():
return sys.stdin.readline().rstrip("\r\n") # for fast input
def ii():
return int(inp())
def si():
return str(inp())
def li(lag = 0):
l = list(map(int, inp().split()))
if lag != 0:
for i in range(len(l)):
l[i] += lag
return l
def mi(lag = 0):
matrix = list()
for i in range(n):
matrix.append(li(lag))
return matrix
def lsi(): #string list
return list(map(str, inp().split()))
def print_list(lista, space = " "):
print(space.join(map(str, lista)))
######################
### BISECT METHODS ###
######################
def bisect_left(a, x):
"""i tale che a[i] >= x e a[i-1] < x"""
left = 0
right = len(a)
while left < right:
mid = (left+right)//2
if a[mid] < x:
left = mid+1
else:
right = mid
return left
def bisect_right(a, x):
"""i tale che a[i] > x e a[i-1] <= x"""
left = 0
right = len(a)
while left < right:
mid = (left+right)//2
if a[mid] > x:
right = mid
else:
left = mid+1
return left
def bisect_elements(a, x):
"""elementi pari a x nell'árray sortato"""
return bisect_right(a, x) - bisect_left(a, x)
######################
### MOD OPERATION ####
######################
MOD = 10**9 + 7
maxN = 5
FACT = [0] * maxN
INV_FACT = [0] * maxN
def add(x, y):
return (x+y) % MOD
def multiply(x, y):
return (x*y) % MOD
def power(x, y):
if y == 0:
return 1
elif y % 2:
return multiply(x, power(x, y-1))
else:
a = power(x, y//2)
return multiply(a, a)
def inverse(x):
return power(x, MOD-2)
def divide(x, y):
return multiply(x, inverse(y))
def allFactorials():
FACT[0] = 1
for i in range(1, maxN):
FACT[i] = multiply(i, FACT[i-1])
def inverseFactorials():
n = len(INV_FACT)
INV_FACT[n-1] = inverse(FACT[n-1])
for i in range(n-2, -1, -1):
INV_FACT[i] = multiply(INV_FACT[i+1], i+1)
def coeffBinom(n, k):
if n < k:
return 0
return multiply(FACT[n], multiply(INV_FACT[k], INV_FACT[n-k]))
######################
#### GRAPH ALGOS #####
######################
# ZERO BASED GRAPH
def create_graph(n, m, undirected = 1, unweighted = 1):
graph = [[] for i in range(n)]
if unweighted:
for i in range(m):
[x, y] = li(lag = -1)
graph[x].append(y)
if undirected:
graph[y].append(x)
else:
for i in range(m):
[x, y, w] = li(lag = -1)
w += 1
graph[x].append([y,w])
if undirected:
graph[y].append([x,w])
return graph
def create_tree(n, unweighted = 1):
children = [[] for i in range(n)]
if unweighted:
for i in range(n-1):
[x, y] = li(lag = -1)
children[x].append(y)
children[y].append(x)
else:
for i in range(n-1):
[x, y, w] = li(lag = -1)
w += 1
children[x].append([y, w])
children[y].append([x, w])
return children
def dist(tree, n, A, B = -1):
s = [[A, 0]]
massimo, massimo_nodo = 0, 0
distanza = -1
v = [-1] * n
while s:
el, dis = s.pop()
if dis > massimo:
massimo = dis
massimo_nodo = el
if el == B:
distanza = dis
for child in tree[el]:
if v[child] == -1:
v[child] = 1
s.append([child, dis+1])
return massimo, massimo_nodo, distanza
def diameter(tree):
_, foglia, _ = dist(tree, n, 0)
diam, _, _ = dist(tree, n, foglia)
return diam
def dfs(graph, n, A):
v = [-1] * n
s = [[A, 0]]
v[A] = 0
while s:
el, dis = s.pop()
for child in graph[el]:
if v[child] == -1:
v[child] = dis + 1
s.append([child, dis + 1])
return v #visited: -1 if not visited, otherwise v[B] is the distance in terms of edges
def bfs(graph, n, A):
v = [-1] * n
s = deque()
s.append([A, 0])
v[A] = 0
while s:
el, dis = s.popleft()
for child in graph[el]:
if v[child] == -1:
v[child] = dis + 1
s.append([child, dis + 1])
return v #visited: -1 if not visited, otherwise v[B] is the distance in terms of edges
#FROM A GIVEN ROOT, RECOVER THE STRUCTURE
def parents_children_root_unrooted_tree(tree, n, root = 0):
q = deque()
visited = [0] * n
parent = [-1] * n
children = [[] for i in range(n)]
q.append(root)
while q:
all_done = 1
visited[q[0]] = 1
for child in tree[q[0]]:
if not visited[child]:
all_done = 0
q.appendleft(child)
if all_done:
for child in tree[q[0]]:
if parent[child] == -1:
parent[q[0]] = child
children[child].append(q[0])
q.popleft()
return parent, children
# CALCULATING LONGEST PATH FOR ALL THE NODES
def all_longest_path_passing_from_node(parent, children, n):
q = deque()
visited = [len(children[i]) for i in range(n)]
downwards = [[0,0] for i in range(n)]
upward = [1] * n
longest_path = [1] * n
for i in range(n):
if not visited[i]:
q.append(i)
downwards[i] = [1,0]
while q:
node = q.popleft()
if parent[node] != -1:
visited[parent[node]] -= 1
if not visited[parent[node]]:
q.append(parent[node])
else:
root = node
for child in children[node]:
downwards[node] = sorted([downwards[node][0], downwards[node][1], downwards[child][0] + 1], reverse = True)[0:2]
s = [node]
while s:
node = s.pop()
if parent[node] != -1:
if downwards[parent[node]][0] == downwards[node][0] + 1:
upward[node] = 1 + max(upward[parent[node]], downwards[parent[node]][1])
else:
upward[node] = 1 + max(upward[parent[node]], downwards[parent[node]][0])
longest_path[node] = downwards[node][0] + downwards[node][1] + upward[node] - min([downwards[node][0], downwards[node][1], upward[node]]) - 1
for child in children[node]:
s.append(child)
return longest_path
### TBD SUCCESSOR GRAPH 7.5
### TBD TREE QUERIES 10.2 da 2 a 4
### TBD ADVANCED TREE 10.3
### TBD GRAPHS AND MATRICES 11.3.3 e 11.4.3 e 11.5.3 (ON GAMES)
######################
## END OF LIBRARIES ##
######################
def check(i,j,n,m):
return i > -1 and j > -1 and i < n and j < m
def dfs_len(tab, i,j):
d = [-1,0,1,0,-1]
n = len(tab)
m = len(tab[0])
stack = list()
stack.append([i,j])
visti[i][j] = 1
count = 0
while stack:
a,b = stack.pop()
count += 1
for k in range(4):
x = a+d[k]
y = b+d[k+1]
if check(x,y,n,m) and tab[x][y] == "." and visti[x][y] == 0:
visti[x][y] = 1
par[x][y] = i*m + j
stack.append([x,y])
return count
n,m = li()
tab = list()
for i in range(n):
tab.append(si())
visti = [[0 for i in range(m)] for j in range(n)]
par = [[-1 for i in range(m)] for j in range(n)]
le = [[0 for i in range(m)] for j in range(n)]
for i in range(n):
for j in range(m):
if tab[i][j] == "." and visti[i][j] == 0:
par[i][j] = i*m + j
count = dfs_len(tab,i,j)
le[i][j] = count
d = [-1,0,1,0,-1]
res = [["." for i in range(m)] for j in range(n)]
for i in range(n):
for j in range(m):
if tab[i][j] != ".":
count = 1
parenti = list()
for k in range(4):
x = i+d[k]
y = j+d[k+1]
if check(x,y,n,m):
p = par[x][y]
if p not in parenti:
parenti.append(p)
for p in parenti:
if p != -1:
yj = p % m
xi = p // m
count += le[xi][yj]
res[i][j] = count%10
for i in range(n):
print_list(res[i], "")
``` | output | 1 | 26,044 | 23 | 52,089 |
Provide tags and a correct Python 3 solution for this coding contest problem.
You are given a rectangular field of n × m cells. Each cell is either empty or impassable (contains an obstacle). Empty cells are marked with '.', impassable cells are marked with '*'. Let's call two empty cells adjacent if they share a side.
Let's call a connected component any non-extendible set of cells such that any two of them are connected by the path of adjacent cells. It is a typical well-known definition of a connected component.
For each impassable cell (x, y) imagine that it is an empty cell (all other cells remain unchanged) and find the size (the number of cells) of the connected component which contains (x, y). You should do it for each impassable cell independently.
The answer should be printed as a matrix with n rows and m columns. The j-th symbol of the i-th row should be "." if the cell is empty at the start. Otherwise the j-th symbol of the i-th row should contain the only digit —- the answer modulo 10. The matrix should be printed without any spaces.
To make your output faster it is recommended to build the output as an array of n strings having length m and print it as a sequence of lines. It will be much faster than writing character-by-character.
As input/output can reach huge size it is recommended to use fast input/output methods: for example, prefer to use scanf/printf instead of cin/cout in C++, prefer to use BufferedReader/PrintWriter instead of Scanner/System.out in Java.
Input
The first line contains two integers n, m (1 ≤ n, m ≤ 1000) — the number of rows and columns in the field.
Each of the next n lines contains m symbols: "." for empty cells, "*" for impassable cells.
Output
Print the answer as a matrix as described above. See the examples to precise the format of the output.
Examples
Input
3 3
*.*
.*.
*.*
Output
3.3
.5.
3.3
Input
4 5
**..*
..***
.*.*.
*.*.*
Output
46..3
..732
.6.4.
5.4.3
Note
In first example, if we imagine that the central cell is empty then it will be included to component of size 5 (cross). If any of the corner cell will be empty then it will be included to component of size 3 (corner). | instruction | 0 | 26,045 | 23 | 52,090 |
Tags: dfs and similar
Correct Solution:
```
import sys
n, m = map(int, sys.stdin.buffer.readline().decode('utf-8').split())
a = [list(line.decode('utf-8').rstrip()) for line in sys.stdin.buffer]
group = [[0]*m for _ in range(n)]
size = [0]
gi = 1
for i in range(n):
for j in range(m):
if a[i][j] == '*' or group[i][j] != 0:
continue
stack = [(i, j)]
cnt = 1
group[i][j] = gi
while stack:
y, x = stack.pop()
for ty, tx in ((y+1, x), (y-1, x), (y, x+1), (y, x-1)):
if 0 <= ty < n and 0 <= tx < m and a[ty][tx] == '.' and group[ty][tx] == 0:
group[ty][tx] = gi
stack.append((ty, tx))
cnt += 1
size.append(cnt)
gi += 1
for i in range(n):
for j in range(m):
if a[i][j] != '*':
continue
adj = set()
for ty, tx in ((i+1, j), (i-1, j), (i, j+1), (i, j-1)):
if 0 <= ty < n and 0 <= tx < m and a[ty][tx] == '.':
adj.add(group[ty][tx])
res = 1
for g in adj:
res += size[g]
a[i][j] = str(res)[-1]
sys.stdout.buffer.write(('\n'.join(''.join(row) for row in a)).encode('utf-8'))
``` | output | 1 | 26,045 | 23 | 52,091 |
Provide tags and a correct Python 3 solution for this coding contest problem.
You are given a rectangular field of n × m cells. Each cell is either empty or impassable (contains an obstacle). Empty cells are marked with '.', impassable cells are marked with '*'. Let's call two empty cells adjacent if they share a side.
Let's call a connected component any non-extendible set of cells such that any two of them are connected by the path of adjacent cells. It is a typical well-known definition of a connected component.
For each impassable cell (x, y) imagine that it is an empty cell (all other cells remain unchanged) and find the size (the number of cells) of the connected component which contains (x, y). You should do it for each impassable cell independently.
The answer should be printed as a matrix with n rows and m columns. The j-th symbol of the i-th row should be "." if the cell is empty at the start. Otherwise the j-th symbol of the i-th row should contain the only digit —- the answer modulo 10. The matrix should be printed without any spaces.
To make your output faster it is recommended to build the output as an array of n strings having length m and print it as a sequence of lines. It will be much faster than writing character-by-character.
As input/output can reach huge size it is recommended to use fast input/output methods: for example, prefer to use scanf/printf instead of cin/cout in C++, prefer to use BufferedReader/PrintWriter instead of Scanner/System.out in Java.
Input
The first line contains two integers n, m (1 ≤ n, m ≤ 1000) — the number of rows and columns in the field.
Each of the next n lines contains m symbols: "." for empty cells, "*" for impassable cells.
Output
Print the answer as a matrix as described above. See the examples to precise the format of the output.
Examples
Input
3 3
*.*
.*.
*.*
Output
3.3
.5.
3.3
Input
4 5
**..*
..***
.*.*.
*.*.*
Output
46..3
..732
.6.4.
5.4.3
Note
In first example, if we imagine that the central cell is empty then it will be included to component of size 5 (cross). If any of the corner cell will be empty then it will be included to component of size 3 (corner). | instruction | 0 | 26,046 | 23 | 52,092 |
Tags: dfs and similar
Correct Solution:
```
import sys
input=sys.stdin.readline
from collections import defaultdict
class UnionFind:
def __init__(self, n):
self.table = [-1] * n
def root(self, x):
stack = []
tbl = self.table
while tbl[x] >= 0:
stack.append(x)
x = tbl[x]
for y in stack:
tbl[y] = x
return x
def find(self, x, y):
return self.root(x) == self.root(y)
def unite(self, x, y):
r1 = self.root(x)
r2 = self.root(y)
if r1 == r2:
return
d1 = self.table[r1]
d2 = self.table[r2]
if d1 <= d2:
self.table[r2] = r1
self.table[r1] += d2
else:
self.table[r1] = r2
self.table[r2] += d1
def get_size(self, x):
return -self.table[self.root(x)]
n,m=map(int,input().split())
a=[list(input().rstrip()) for i in range(n)]
uf=UnionFind(n*m)
dx=[1,0,-1,0]
dy=[0,1,0,-1]
for i in range(n):
for j in range(m):
if a[i][j]==".":
for k in range(4):
ni=i+dy[k];nj=j+dx[k]
if 0<=ni<n and 0<=nj<m and a[ni][nj]==".":
uf.unite(m*i+j,m*ni+nj)
ans=[[""]*m for i in range(n)]
for i in range(n):
for j in range(m):
if a[i][j]==".":
ans[i][j]="."
else:
tmp=0
use=[]
for k in range(4):
ni,nj=i+dy[k],j+dx[k]
if 0<=ni<n and 0<=nj<m and a[ni][nj]==".":
flag=True
for val in use:
if uf.find(val,m*ni+nj):
flag=False
if flag:
use.append(m*ni+nj)
tmp+=uf.get_size(m*ni+nj)
ans[i][j]=str((tmp+1)%10)
for i in range(n):
print("".join(ans[i]))
``` | output | 1 | 26,046 | 23 | 52,093 |
Provide tags and a correct Python 3 solution for this coding contest problem.
You are given a rectangular field of n × m cells. Each cell is either empty or impassable (contains an obstacle). Empty cells are marked with '.', impassable cells are marked with '*'. Let's call two empty cells adjacent if they share a side.
Let's call a connected component any non-extendible set of cells such that any two of them are connected by the path of adjacent cells. It is a typical well-known definition of a connected component.
For each impassable cell (x, y) imagine that it is an empty cell (all other cells remain unchanged) and find the size (the number of cells) of the connected component which contains (x, y). You should do it for each impassable cell independently.
The answer should be printed as a matrix with n rows and m columns. The j-th symbol of the i-th row should be "." if the cell is empty at the start. Otherwise the j-th symbol of the i-th row should contain the only digit —- the answer modulo 10. The matrix should be printed without any spaces.
To make your output faster it is recommended to build the output as an array of n strings having length m and print it as a sequence of lines. It will be much faster than writing character-by-character.
As input/output can reach huge size it is recommended to use fast input/output methods: for example, prefer to use scanf/printf instead of cin/cout in C++, prefer to use BufferedReader/PrintWriter instead of Scanner/System.out in Java.
Input
The first line contains two integers n, m (1 ≤ n, m ≤ 1000) — the number of rows and columns in the field.
Each of the next n lines contains m symbols: "." for empty cells, "*" for impassable cells.
Output
Print the answer as a matrix as described above. See the examples to precise the format of the output.
Examples
Input
3 3
*.*
.*.
*.*
Output
3.3
.5.
3.3
Input
4 5
**..*
..***
.*.*.
*.*.*
Output
46..3
..732
.6.4.
5.4.3
Note
In first example, if we imagine that the central cell is empty then it will be included to component of size 5 (cross). If any of the corner cell will be empty then it will be included to component of size 3 (corner). | instruction | 0 | 26,047 | 23 | 52,094 |
Tags: dfs and similar
Correct Solution:
```
from sys import stdin, stdout
n, m = map(int, stdin.readline().split())
mtx = [[ch for ch in stdin.readline()] for _ in range(n)]
groups = [[0 for _ in range(m)] for _ in range(n)]
sizes = [0]
shard_id = 1
for i in range(n):
for j in range(m):
if mtx[i][j] == '*':
continue
if groups[i][j] != 0:
continue
stack = [(i, j)]
size = 1
groups[i][j] = shard_id
while stack:
x, y = stack.pop()
for xi, yi in ((x + 1, y), (x - 1, y), (x, y + 1), (x, y - 1)):
if xi < 0 or n <= xi:
continue
if yi < 0 or m <= yi:
continue
if mtx[xi][yi] != ".":
continue
if groups[xi][yi] != 0:
continue
groups[xi][yi] = shard_id
stack.append((xi, yi))
size += 1
sizes.append(size)
shard_id += 1
for i in range(n):
for j in range(m):
if mtx[i][j] != '*':
continue
groups_id = set()
for xi, yi in ((i + 1, j), (i - 1, j), (i, j + 1), (i, j - 1)):
if xi < 0 or n <= xi:
continue
if yi < 0 or m <= yi:
continue
if mtx[xi][yi] != ".":
continue
groups_id.add(groups[xi][yi])
size = 1
for gid in groups_id:
size += sizes[gid]
mtx[i][j] = str(size)[-1]
stdout.write(('\n'.join(''.join(row) for row in mtx)))
``` | output | 1 | 26,047 | 23 | 52,095 |
Provide tags and a correct Python 3 solution for this coding contest problem.
You are given a rectangular field of n × m cells. Each cell is either empty or impassable (contains an obstacle). Empty cells are marked with '.', impassable cells are marked with '*'. Let's call two empty cells adjacent if they share a side.
Let's call a connected component any non-extendible set of cells such that any two of them are connected by the path of adjacent cells. It is a typical well-known definition of a connected component.
For each impassable cell (x, y) imagine that it is an empty cell (all other cells remain unchanged) and find the size (the number of cells) of the connected component which contains (x, y). You should do it for each impassable cell independently.
The answer should be printed as a matrix with n rows and m columns. The j-th symbol of the i-th row should be "." if the cell is empty at the start. Otherwise the j-th symbol of the i-th row should contain the only digit —- the answer modulo 10. The matrix should be printed without any spaces.
To make your output faster it is recommended to build the output as an array of n strings having length m and print it as a sequence of lines. It will be much faster than writing character-by-character.
As input/output can reach huge size it is recommended to use fast input/output methods: for example, prefer to use scanf/printf instead of cin/cout in C++, prefer to use BufferedReader/PrintWriter instead of Scanner/System.out in Java.
Input
The first line contains two integers n, m (1 ≤ n, m ≤ 1000) — the number of rows and columns in the field.
Each of the next n lines contains m symbols: "." for empty cells, "*" for impassable cells.
Output
Print the answer as a matrix as described above. See the examples to precise the format of the output.
Examples
Input
3 3
*.*
.*.
*.*
Output
3.3
.5.
3.3
Input
4 5
**..*
..***
.*.*.
*.*.*
Output
46..3
..732
.6.4.
5.4.3
Note
In first example, if we imagine that the central cell is empty then it will be included to component of size 5 (cross). If any of the corner cell will be empty then it will be included to component of size 3 (corner). | instruction | 0 | 26,048 | 23 | 52,096 |
Tags: dfs and similar
Correct Solution:
```
# n=int(input())
# n,k=map(int,input().split())
# arr=list(map(int,input().split()))
#ls=list(map(int,input().split()))
#for i in range(m):
# for _ in range(int(input())):
from collections import Counter
#from fractions import Fraction
#n=int(input())
#arr=list(map(int,input().split()))
#ls = [list(map(int, input().split())) for i in range(n)]
from math import log2
#for _ in range(int(input())):
#n, m = map(int, input().split())
# for _ in range(int(input())):
from math import gcd
#n=int(input())
# for i in range(m):
# for i in range(int(input())):
# n,k= map(int, input().split())
# arr=list(map(int,input().split()))
# n=sys.stdin.readline()
# n=int(n)
# n,k= map(int, input().split())
# arr=list(map(int,input().split()))
# n=int(inaput())
#for _ in range(int(input())):
#arr=list(map(int,input().split()))
from collections import deque
dx=[-1,0,0,1]
dy=[0,-1,1,0]
def bfs(x,y):
global total
total+=1
q=deque([(x,y)])
v[x][y]=True
h[x][y]=comp
#q.append()
while q:
x,y=q.pop()
for i in range(4):
nx=x+dx[i]
ny=y+dy[i]
#print("nx,y",nx, ny)
if (nx>=0 and nx<n) and (ny>=0 and ny<m) and (v[nx][ny]==False) and (g[nx][ny]=="."):
q.appendleft((nx,ny))
total+=1
v[nx][ny]=True
h[nx][ny]=comp
#global g,h,r,comp,total
n, m = map(int, input().split())
h=[[-1 for i in range(m)] for j in range(n)]
g=[]
v=[[False for i in range(m)]for j in range(n)]
for i in range(n):
g.append(list(input()))
component=[]
for i in range(n):
for j in range(m):
if v[i][j]==False and g[i][j]==".":############
comp=len(component)
#global total
total=0
bfs(i,j)
component.append(total)
#print(component)
for x in range(n):
for y in range(m):
if g[x][y] == "*":
ans = 0
s = set()
for k in range(4):
nx = x + dx[k]
ny = y + dy[k]
if nx >= 0 and nx < n and ny >= 0 and ny < m and g[nx][ny] == ".":
s.add(h[nx][ny])
for itm in s:
ans += component[itm]
ans += 1
ans %= 10
g[x][y] = str(ans)
for i in range(n):
print("".join(g[i]))
``` | output | 1 | 26,048 | 23 | 52,097 |
Provide tags and a correct Python 3 solution for this coding contest problem.
You are given a rectangular field of n × m cells. Each cell is either empty or impassable (contains an obstacle). Empty cells are marked with '.', impassable cells are marked with '*'. Let's call two empty cells adjacent if they share a side.
Let's call a connected component any non-extendible set of cells such that any two of them are connected by the path of adjacent cells. It is a typical well-known definition of a connected component.
For each impassable cell (x, y) imagine that it is an empty cell (all other cells remain unchanged) and find the size (the number of cells) of the connected component which contains (x, y). You should do it for each impassable cell independently.
The answer should be printed as a matrix with n rows and m columns. The j-th symbol of the i-th row should be "." if the cell is empty at the start. Otherwise the j-th symbol of the i-th row should contain the only digit —- the answer modulo 10. The matrix should be printed without any spaces.
To make your output faster it is recommended to build the output as an array of n strings having length m and print it as a sequence of lines. It will be much faster than writing character-by-character.
As input/output can reach huge size it is recommended to use fast input/output methods: for example, prefer to use scanf/printf instead of cin/cout in C++, prefer to use BufferedReader/PrintWriter instead of Scanner/System.out in Java.
Input
The first line contains two integers n, m (1 ≤ n, m ≤ 1000) — the number of rows and columns in the field.
Each of the next n lines contains m symbols: "." for empty cells, "*" for impassable cells.
Output
Print the answer as a matrix as described above. See the examples to precise the format of the output.
Examples
Input
3 3
*.*
.*.
*.*
Output
3.3
.5.
3.3
Input
4 5
**..*
..***
.*.*.
*.*.*
Output
46..3
..732
.6.4.
5.4.3
Note
In first example, if we imagine that the central cell is empty then it will be included to component of size 5 (cross). If any of the corner cell will be empty then it will be included to component of size 3 (corner). | instruction | 0 | 26,049 | 23 | 52,098 |
Tags: dfs and similar
Correct Solution:
```
from sys import stdin,stdout
st=lambda:list(stdin.readline().strip())
li=lambda:list(map(int,stdin.readline().split()))
mp=lambda:map(int,stdin.readline().split())
inp=lambda:int(stdin.readline())
pr=lambda n: stdout.write(str(n)+"\n")
def valid(x,y):
if x>=n or y>=m or x<0 or y<0:
return False
if v[x][y] or l[x][y]=='*':
return False
return True
dx=[-1,1,0,0]
dy=[0,0,1,-1]
def DFS(i,j,val):
ans=1
connected=[(i,j)]
stack=[(i,j)]
v[i][j]=True
while stack:
a,b=stack.pop()
for x in range(4):
newX,newY=a+dx[x], b+dy[x]
if valid(newX,newY):
stack.append((newX,newY))
v[newX][newY]=True
connected.append((newX,newY))
ans= ans+1
for i in connected:
a,b=i
l[a][b]=(ans,val)
n,m=mp()
l=[st() for i in range(n)]
val=0
k=[list(i) for i in l]
v=[[False for i in range(m)] for j in range(n)]
for i in range(n):
for j in range(m):
if l[i][j]=='.' and not v[i][j]:
DFS(i,j,val)
val+=1
for i in range(n):
for j in range(m):
if l[i][j]=='*':
k[i][j]=1
s=set()
for x in range(4):
newX,newY= i+dx[x], j+dy[x]
if 0<=newX<n and 0<=newY<m:
if type(l[newX][newY])==tuple:
A,B=l[newX][newY]
if B not in s:
k[i][j]+=A
k[i][j]%=10
s.add(B)
print('\n'.join([''.join([str(i) for i in j]) for j in k]))
``` | output | 1 | 26,049 | 23 | 52,099 |
Provide tags and a correct Python 3 solution for this coding contest problem.
You are given a rectangular field of n × m cells. Each cell is either empty or impassable (contains an obstacle). Empty cells are marked with '.', impassable cells are marked with '*'. Let's call two empty cells adjacent if they share a side.
Let's call a connected component any non-extendible set of cells such that any two of them are connected by the path of adjacent cells. It is a typical well-known definition of a connected component.
For each impassable cell (x, y) imagine that it is an empty cell (all other cells remain unchanged) and find the size (the number of cells) of the connected component which contains (x, y). You should do it for each impassable cell independently.
The answer should be printed as a matrix with n rows and m columns. The j-th symbol of the i-th row should be "." if the cell is empty at the start. Otherwise the j-th symbol of the i-th row should contain the only digit —- the answer modulo 10. The matrix should be printed without any spaces.
To make your output faster it is recommended to build the output as an array of n strings having length m and print it as a sequence of lines. It will be much faster than writing character-by-character.
As input/output can reach huge size it is recommended to use fast input/output methods: for example, prefer to use scanf/printf instead of cin/cout in C++, prefer to use BufferedReader/PrintWriter instead of Scanner/System.out in Java.
Input
The first line contains two integers n, m (1 ≤ n, m ≤ 1000) — the number of rows and columns in the field.
Each of the next n lines contains m symbols: "." for empty cells, "*" for impassable cells.
Output
Print the answer as a matrix as described above. See the examples to precise the format of the output.
Examples
Input
3 3
*.*
.*.
*.*
Output
3.3
.5.
3.3
Input
4 5
**..*
..***
.*.*.
*.*.*
Output
46..3
..732
.6.4.
5.4.3
Note
In first example, if we imagine that the central cell is empty then it will be included to component of size 5 (cross). If any of the corner cell will be empty then it will be included to component of size 3 (corner). | instruction | 0 | 26,050 | 23 | 52,100 |
Tags: dfs and similar
Correct Solution:
```
from collections import defaultdict
import sys
input = sys.stdin.readline
def get_root(s):
v = []
while not s == root[s]:
v.append(s)
s = root[s]
for i in v:
root[i] = s
return s
def unite(s, t):
root_s = get_root(s)
root_t = get_root(t)
if not root_s == root_t:
if rank[s] == rank[t]:
root[root_t] = root_s
rank[root_s] += 1
size[root_s] += size[root_t]
elif rank[s] > rank[t]:
root[root_t] = root_s
size[root_s] += size[root_t]
else:
root[root_s] = root_t
size[root_t] += size[root_s]
def same(s, t):
if get_root(s) == get_root(t):
return True
else:
return False
n, m = map(int, input().split())
l = n * m
root = [i for i in range(l)]
rank = [1 for _ in range(l)]
size = [1 for _ in range(l)]
s = []
for i in range(n):
s0 = list(input().rstrip())
for j in range(m - 1):
if s0[j] == s0[j + 1] == ".":
unite(m * i + j, m * i + j + 1)
s.append(s0)
for i in range(n - 1):
for j in range(m):
if s[i][j] == s[i + 1][j] == ".":
if not same(m * i + j, m * (i + 1) + j):
unite(m * i + j, m * (i + 1) + j)
cnt = defaultdict(lambda : 0)
r = [0] * l
for i in range(l):
x = get_root(i)
r[i] = x
cnt[x] += 1
v = [(1, 0), (-1, 0), (0, 1), (0, -1)]
for i in range(n):
for j in range(m):
if not s[i][j] == "*":
continue
s0 = set()
for di, dj in v:
ni, nj = i + di, j + dj
if 0 <= ni < n and 0 <= nj < m:
if s[ni][nj] == ".":
s0.add(r[m * ni + nj])
ans = 1
for k in s0:
ans += cnt[k]
s[i][j] = str(ans % 10)
for s0 in s:
print("".join(s0))
``` | output | 1 | 26,050 | 23 | 52,101 |
Provide tags and a correct Python 3 solution for this coding contest problem.
You are given a rectangular field of n × m cells. Each cell is either empty or impassable (contains an obstacle). Empty cells are marked with '.', impassable cells are marked with '*'. Let's call two empty cells adjacent if they share a side.
Let's call a connected component any non-extendible set of cells such that any two of them are connected by the path of adjacent cells. It is a typical well-known definition of a connected component.
For each impassable cell (x, y) imagine that it is an empty cell (all other cells remain unchanged) and find the size (the number of cells) of the connected component which contains (x, y). You should do it for each impassable cell independently.
The answer should be printed as a matrix with n rows and m columns. The j-th symbol of the i-th row should be "." if the cell is empty at the start. Otherwise the j-th symbol of the i-th row should contain the only digit —- the answer modulo 10. The matrix should be printed without any spaces.
To make your output faster it is recommended to build the output as an array of n strings having length m and print it as a sequence of lines. It will be much faster than writing character-by-character.
As input/output can reach huge size it is recommended to use fast input/output methods: for example, prefer to use scanf/printf instead of cin/cout in C++, prefer to use BufferedReader/PrintWriter instead of Scanner/System.out in Java.
Input
The first line contains two integers n, m (1 ≤ n, m ≤ 1000) — the number of rows and columns in the field.
Each of the next n lines contains m symbols: "." for empty cells, "*" for impassable cells.
Output
Print the answer as a matrix as described above. See the examples to precise the format of the output.
Examples
Input
3 3
*.*
.*.
*.*
Output
3.3
.5.
3.3
Input
4 5
**..*
..***
.*.*.
*.*.*
Output
46..3
..732
.6.4.
5.4.3
Note
In first example, if we imagine that the central cell is empty then it will be included to component of size 5 (cross). If any of the corner cell will be empty then it will be included to component of size 3 (corner). | instruction | 0 | 26,051 | 23 | 52,102 |
Tags: dfs and similar
Correct Solution:
```
import sys
input = sys.stdin.readline
n, m = map(int, input().split())
class DisjointSetUnion:
def __init__(self, n):
self.parent = list(range(n))
self.size = [1] * n
self.num_sets = n
def find(self, a):
acopy = a
while a != self.parent[a]:
a = self.parent[a]
while acopy != a:
self.parent[acopy], acopy = a, self.parent[acopy]
return a
def union(self, a, b):
a, b = self.find(a), self.find(b)
if a != b:
if self.size[a] < self.size[b]:
a, b = b, a
self.num_sets -= 1
self.parent[b] = a
self.size[a] += self.size[b]
def set_size(self, a):
return self.size[self.find(a)]
def __len__(self):
return self.num_sets
l = []
for i in range(n):
l.append(input().strip())
UF = DisjointSetUnion(n * m)
for i in range(n):
for j in range(m):
if i < n - 1:
if l[i][j] == '.' and l[i+1][j] == '.':
UF.union(m * i + j, m * i + m + j)
if j < m - 1:
if l[i][j] == '.' and l[i][j+1] =='.':
UF.union(m * i + j, m * i + j + 1)
out = []
for i in range(n):
curr = []
for j in range(m):
if l[i][j] == '.':
curr.append('.')
else:
dx = [0,0,-1,1]
dy = [-1,1,0,0]
adj = set()
for d in range(4):
nx = i + dx[d]
ny = j + dy[d]
if 0 <= nx < n and 0 <= ny < m and l[nx][ny] == '.':
adj.add(UF.find(m * nx + ny))
outV = 1
for v in adj:
outV += UF.set_size(v)
curr.append(str(outV % 10))
out.append(''.join(curr))
print('\n'.join(out))
``` | output | 1 | 26,051 | 23 | 52,103 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
You are given a rectangular field of n × m cells. Each cell is either empty or impassable (contains an obstacle). Empty cells are marked with '.', impassable cells are marked with '*'. Let's call two empty cells adjacent if they share a side.
Let's call a connected component any non-extendible set of cells such that any two of them are connected by the path of adjacent cells. It is a typical well-known definition of a connected component.
For each impassable cell (x, y) imagine that it is an empty cell (all other cells remain unchanged) and find the size (the number of cells) of the connected component which contains (x, y). You should do it for each impassable cell independently.
The answer should be printed as a matrix with n rows and m columns. The j-th symbol of the i-th row should be "." if the cell is empty at the start. Otherwise the j-th symbol of the i-th row should contain the only digit —- the answer modulo 10. The matrix should be printed without any spaces.
To make your output faster it is recommended to build the output as an array of n strings having length m and print it as a sequence of lines. It will be much faster than writing character-by-character.
As input/output can reach huge size it is recommended to use fast input/output methods: for example, prefer to use scanf/printf instead of cin/cout in C++, prefer to use BufferedReader/PrintWriter instead of Scanner/System.out in Java.
Input
The first line contains two integers n, m (1 ≤ n, m ≤ 1000) — the number of rows and columns in the field.
Each of the next n lines contains m symbols: "." for empty cells, "*" for impassable cells.
Output
Print the answer as a matrix as described above. See the examples to precise the format of the output.
Examples
Input
3 3
*.*
.*.
*.*
Output
3.3
.5.
3.3
Input
4 5
**..*
..***
.*.*.
*.*.*
Output
46..3
..732
.6.4.
5.4.3
Note
In first example, if we imagine that the central cell is empty then it will be included to component of size 5 (cross). If any of the corner cell will be empty then it will be included to component of size 3 (corner).
Submitted Solution:
```
from sys import stdin,stdout
st=lambda:list(stdin.readline().strip())
li=lambda:list(map(int,stdin.readline().split()))
mp=lambda:map(int,stdin.readline().split())
inp=lambda:int(stdin.readline())
pr=lambda n: stdout.write(str(n)+"\n")
def valid(x,y):
if x>=n or y>=m or x<0 or y<0:
return False
if v[x][y] or l[x][y]=='*':
return False
return True
dx=[-1,1,0,0]
dy=[0,0,1,-1]
def DFS(i,j,val):
ans=1
connected=[(i,j)]
stack=[(i,j)]
v[i][j]=True
while stack:
a,b=stack.pop()
for x in range(4):
newX,newY=a+dx[x], b+dy[x]
if valid(newX,newY):
stack.append((newX,newY))
v[newX][newY]=True
connected.append((newX,newY))
ans= (ans%10 + 1%10) % 10
for i in connected:
a,b=i
l[a][b]=(ans,val)
n,m=mp()
l=[st() for i in range(n)]
val=0
k=[list(i) for i in l]
v=[[False for i in range(m)] for j in range(n)]
for i in range(n):
for j in range(m):
if l[i][j]=='.' and not v[i][j]:
DFS(i,j,val)
val+=1
for i in range(n):
for j in range(m):
if l[i][j]=='*':
k[i][j]=1
s=set()
for x in range(4):
newX,newY= i+dx[x], j+dy[x]
if newX>=0 and newY>=0 and newX<n and newY<m:
if type(l[newX][newY])==tuple:
A,B=l[newX][newY]
if B not in s:
k[i][j]+=A
k[i][j]%=10
s.add(B)
print('\n'.join([''.join([str(i) for i in j]) for j in k]))
``` | instruction | 0 | 26,052 | 23 | 52,104 |
Yes | output | 1 | 26,052 | 23 | 52,105 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
You are given a rectangular field of n × m cells. Each cell is either empty or impassable (contains an obstacle). Empty cells are marked with '.', impassable cells are marked with '*'. Let's call two empty cells adjacent if they share a side.
Let's call a connected component any non-extendible set of cells such that any two of them are connected by the path of adjacent cells. It is a typical well-known definition of a connected component.
For each impassable cell (x, y) imagine that it is an empty cell (all other cells remain unchanged) and find the size (the number of cells) of the connected component which contains (x, y). You should do it for each impassable cell independently.
The answer should be printed as a matrix with n rows and m columns. The j-th symbol of the i-th row should be "." if the cell is empty at the start. Otherwise the j-th symbol of the i-th row should contain the only digit —- the answer modulo 10. The matrix should be printed without any spaces.
To make your output faster it is recommended to build the output as an array of n strings having length m and print it as a sequence of lines. It will be much faster than writing character-by-character.
As input/output can reach huge size it is recommended to use fast input/output methods: for example, prefer to use scanf/printf instead of cin/cout in C++, prefer to use BufferedReader/PrintWriter instead of Scanner/System.out in Java.
Input
The first line contains two integers n, m (1 ≤ n, m ≤ 1000) — the number of rows and columns in the field.
Each of the next n lines contains m symbols: "." for empty cells, "*" for impassable cells.
Output
Print the answer as a matrix as described above. See the examples to precise the format of the output.
Examples
Input
3 3
*.*
.*.
*.*
Output
3.3
.5.
3.3
Input
4 5
**..*
..***
.*.*.
*.*.*
Output
46..3
..732
.6.4.
5.4.3
Note
In first example, if we imagine that the central cell is empty then it will be included to component of size 5 (cross). If any of the corner cell will be empty then it will be included to component of size 3 (corner).
Submitted Solution:
```
from sys import stdin,stdout
st=lambda:list(stdin.readline().strip())
li=lambda:list(map(int,stdin.readline().split()))
mp=lambda:map(int,stdin.readline().split())
inp=lambda:int(stdin.readline())
pr=lambda n: stdout.write(str(n)+"\n")
def valid(x,y):
if x>=n or y>=m or x<0 or y<0:
return False
if v[x][y] or l[x][y]=='*':
return False
return True
dx=[-1,1,0,0]
dy=[0,0,1,-1]
def DFS(i,j,val):
ans=1
connected=[(i,j)]
stack=[(i,j)]
v[i][j]=True
while stack:
a,b=stack.pop()
for x in range(4):
newX,newY=a+dx[x], b+dy[x]
if valid(newX,newY):
stack.append((newX,newY))
v[newX][newY]=True
connected.append((newX,newY))
ans= ans+1
for i in connected:
a,b=i
l[a][b]=(ans,val)
n,m=mp()
l=[st() for i in range(n)]
val=0
k=[list(i) for i in l]
v=[[False for i in range(m)] for j in range(n)]
for i in range(n):
for j in range(m):
if l[i][j]=='.' and not v[i][j]:
DFS(i,j,val)
val+=1
for i in range(n):
for j in range(m):
if l[i][j]=='*':
k[i][j]=1
s=set()
for x in range(4):
newX,newY= i+dx[x], j+dy[x]
if newX>=0 and newY>=0 and newX<n and newY<m:
if len(l[newX][newY])==2:
A,B=l[newX][newY]
if B not in s:
k[i][j]+=A
k[i][j]%=10
s.add(B)
print('\n'.join([''.join([str(i) for i in j]) for j in k]))
``` | instruction | 0 | 26,053 | 23 | 52,106 |
Yes | output | 1 | 26,053 | 23 | 52,107 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
You are given a rectangular field of n × m cells. Each cell is either empty or impassable (contains an obstacle). Empty cells are marked with '.', impassable cells are marked with '*'. Let's call two empty cells adjacent if they share a side.
Let's call a connected component any non-extendible set of cells such that any two of them are connected by the path of adjacent cells. It is a typical well-known definition of a connected component.
For each impassable cell (x, y) imagine that it is an empty cell (all other cells remain unchanged) and find the size (the number of cells) of the connected component which contains (x, y). You should do it for each impassable cell independently.
The answer should be printed as a matrix with n rows and m columns. The j-th symbol of the i-th row should be "." if the cell is empty at the start. Otherwise the j-th symbol of the i-th row should contain the only digit —- the answer modulo 10. The matrix should be printed without any spaces.
To make your output faster it is recommended to build the output as an array of n strings having length m and print it as a sequence of lines. It will be much faster than writing character-by-character.
As input/output can reach huge size it is recommended to use fast input/output methods: for example, prefer to use scanf/printf instead of cin/cout in C++, prefer to use BufferedReader/PrintWriter instead of Scanner/System.out in Java.
Input
The first line contains two integers n, m (1 ≤ n, m ≤ 1000) — the number of rows and columns in the field.
Each of the next n lines contains m symbols: "." for empty cells, "*" for impassable cells.
Output
Print the answer as a matrix as described above. See the examples to precise the format of the output.
Examples
Input
3 3
*.*
.*.
*.*
Output
3.3
.5.
3.3
Input
4 5
**..*
..***
.*.*.
*.*.*
Output
46..3
..732
.6.4.
5.4.3
Note
In first example, if we imagine that the central cell is empty then it will be included to component of size 5 (cross). If any of the corner cell will be empty then it will be included to component of size 3 (corner).
Submitted Solution:
```
from sys import stdin,stdout
st=lambda:list(stdin.readline().strip())
li=lambda:list(map(int,stdin.readline().split()))
mp=lambda:map(int,stdin.readline().split())
inp=lambda:int(stdin.readline())
pr=lambda n: stdout.write(str(n)+"\n")
def valid(x,y):
if x>=n or y>=m or x<0 or y<0:
return False
if v[x][y] or l[x][y]=='*':
return False
return True
dx=[-1,1,0,0]
dy=[0,0,1,-1]
def DFS(i,j,val):
ans=1
connected=[(i,j)]
stack=[(i,j)]
v[i][j]=True
while stack:
a,b=stack.pop()
for x in range(4):
newX,newY=a+dx[x], b+dy[x]
if valid(newX,newY):
stack.append((newX,newY))
v[newX][newY]=True
connected.append((newX,newY))
ans= ans+1
for i in connected:
a,b=i
l[a][b]=(ans,val)
n,m=mp()
l=[st() for i in range(n)]
val=0
k=[list(i) for i in l]
v=[[False for i in range(m)] for j in range(n)]
for i in range(n):
for j in range(m):
if l[i][j]=='.' and not v[i][j]:
DFS(i,j,val)
val+=1
for i in range(n):
for j in range(m):
if l[i][j]=='*':
k[i][j]=1
s=set()
for x in range(4):
newX,newY= i+dx[x], j+dy[x]
if newX>=0 and newY>=0 and newX<n and newY<m:
if type(l[newX][newY])==tuple:
A,B=l[newX][newY]
if B not in s:
k[i][j]+=A
k[i][j]%=10
s.add(B)
print('\n'.join([''.join([str(i) for i in j]) for j in k]))
``` | instruction | 0 | 26,054 | 23 | 52,108 |
Yes | output | 1 | 26,054 | 23 | 52,109 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
You are given a rectangular field of n × m cells. Each cell is either empty or impassable (contains an obstacle). Empty cells are marked with '.', impassable cells are marked with '*'. Let's call two empty cells adjacent if they share a side.
Let's call a connected component any non-extendible set of cells such that any two of them are connected by the path of adjacent cells. It is a typical well-known definition of a connected component.
For each impassable cell (x, y) imagine that it is an empty cell (all other cells remain unchanged) and find the size (the number of cells) of the connected component which contains (x, y). You should do it for each impassable cell independently.
The answer should be printed as a matrix with n rows and m columns. The j-th symbol of the i-th row should be "." if the cell is empty at the start. Otherwise the j-th symbol of the i-th row should contain the only digit —- the answer modulo 10. The matrix should be printed without any spaces.
To make your output faster it is recommended to build the output as an array of n strings having length m and print it as a sequence of lines. It will be much faster than writing character-by-character.
As input/output can reach huge size it is recommended to use fast input/output methods: for example, prefer to use scanf/printf instead of cin/cout in C++, prefer to use BufferedReader/PrintWriter instead of Scanner/System.out in Java.
Input
The first line contains two integers n, m (1 ≤ n, m ≤ 1000) — the number of rows and columns in the field.
Each of the next n lines contains m symbols: "." for empty cells, "*" for impassable cells.
Output
Print the answer as a matrix as described above. See the examples to precise the format of the output.
Examples
Input
3 3
*.*
.*.
*.*
Output
3.3
.5.
3.3
Input
4 5
**..*
..***
.*.*.
*.*.*
Output
46..3
..732
.6.4.
5.4.3
Note
In first example, if we imagine that the central cell is empty then it will be included to component of size 5 (cross). If any of the corner cell will be empty then it will be included to component of size 3 (corner).
Submitted Solution:
```
from collections import deque
dirs = [[1, 0], [-1, 0], [0, 1], [0, -1]]
componentsizes = {}
componentid = 0
n, m = map(int, input().split())
field = [list(input()) for _ in range(n)]
def valid(y, x):
return y >= 0 and x >= 0 and y < n and x < m
def component(y, x):
size = 1
q = deque([(y, x)])
field[y][x] = componentid
while q:
y, x = q.pop()
for i, j in dirs:
if valid(y+i, x+j) and field[y+i][x+j] == ".":
q.appendleft((y+i, x+j))
field[y+i][x+j] = componentid
size += 1
return size
def solve(y, x):
connected = set()
for i, j in dirs:
if valid(y+i, x+j) and type(field[y+i][x+j]) is int:
connected.add(field[y+i][x+j])
return (sum(componentsizes[i] for i in connected)+1)%10
for i in range(n):
for j in range(m):
if field[i][j] == ".":
componentsizes[componentid] = component(i, j)
componentid += 1
output = [[] for _ in range(n)]
for i in range(n):
for j in range(m):
output[i].append(str(solve(i, j)) if field[i][j] == "*" else ".")
print("\n".join(["".join(row) for row in output]))
``` | instruction | 0 | 26,055 | 23 | 52,110 |
Yes | output | 1 | 26,055 | 23 | 52,111 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
You are given a rectangular field of n × m cells. Each cell is either empty or impassable (contains an obstacle). Empty cells are marked with '.', impassable cells are marked with '*'. Let's call two empty cells adjacent if they share a side.
Let's call a connected component any non-extendible set of cells such that any two of them are connected by the path of adjacent cells. It is a typical well-known definition of a connected component.
For each impassable cell (x, y) imagine that it is an empty cell (all other cells remain unchanged) and find the size (the number of cells) of the connected component which contains (x, y). You should do it for each impassable cell independently.
The answer should be printed as a matrix with n rows and m columns. The j-th symbol of the i-th row should be "." if the cell is empty at the start. Otherwise the j-th symbol of the i-th row should contain the only digit —- the answer modulo 10. The matrix should be printed without any spaces.
To make your output faster it is recommended to build the output as an array of n strings having length m and print it as a sequence of lines. It will be much faster than writing character-by-character.
As input/output can reach huge size it is recommended to use fast input/output methods: for example, prefer to use scanf/printf instead of cin/cout in C++, prefer to use BufferedReader/PrintWriter instead of Scanner/System.out in Java.
Input
The first line contains two integers n, m (1 ≤ n, m ≤ 1000) — the number of rows and columns in the field.
Each of the next n lines contains m symbols: "." for empty cells, "*" for impassable cells.
Output
Print the answer as a matrix as described above. See the examples to precise the format of the output.
Examples
Input
3 3
*.*
.*.
*.*
Output
3.3
.5.
3.3
Input
4 5
**..*
..***
.*.*.
*.*.*
Output
46..3
..732
.6.4.
5.4.3
Note
In first example, if we imagine that the central cell is empty then it will be included to component of size 5 (cross). If any of the corner cell will be empty then it will be included to component of size 3 (corner).
Submitted Solution:
```
from sys import stdin,stdout
st=lambda:list(stdin.readline().strip())
li=lambda:list(map(int,stdin.readline().split()))
mp=lambda:map(int,stdin.readline().split())
inp=lambda:int(stdin.readline())
pr=lambda n: stdout.write(str(n)+"\n")
def valid(x,y):
if x>=n or y>=m or x<0 or y<0:
return False
if v[x][y] or l[x][y]=='*':
return False
return True
dx=[-1,1,0,0]
dy=[0,0,1,-1]
def DFS(i,j,val):
ans=1
connected=[(i,j)]
stack=[(i,j)]
v[i][j]=True
while stack:
a,b=stack.pop()
for x in range(4):
newX,newY=a+dx[x], b+dy[x]
if valid(newX,newY):
stack.append((newX,newY))
v[newX][newY]=True
connected.append((newX,newY))
ans= (ans%10 + 1%10) % 10
for i in connected:
a,b=i
l[a][b]=(ans,val)
n,m=mp()
l=[st() for i in range(n)]
val=0
k=[list(i) for i in l]
v=[[False for i in range(m)] for j in range(n)]
for i in range(n):
for j in range(m):
if l[i][j]=='.' and not v[i][j]:
DFS(i,j,val)
val+=1
for i in range(n):
for j in range(m):
if l[i][j]=='*':
k[i][j]=1
s=set()
for x in range(4):
newX,newY= i+dx[x], j+dy[x]
if newX>=0 and newY>=0 and newX<n and newY<m:
if type(l[newX][newY])==tuple:
A,B=l[newX][newY]
if B not in s:
k[i][j]+=A
s.add(B)
print('\n'.join([''.join([str(i) for i in j]) for j in k]))
``` | instruction | 0 | 26,056 | 23 | 52,112 |
No | output | 1 | 26,056 | 23 | 52,113 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
You are given a rectangular field of n × m cells. Each cell is either empty or impassable (contains an obstacle). Empty cells are marked with '.', impassable cells are marked with '*'. Let's call two empty cells adjacent if they share a side.
Let's call a connected component any non-extendible set of cells such that any two of them are connected by the path of adjacent cells. It is a typical well-known definition of a connected component.
For each impassable cell (x, y) imagine that it is an empty cell (all other cells remain unchanged) and find the size (the number of cells) of the connected component which contains (x, y). You should do it for each impassable cell independently.
The answer should be printed as a matrix with n rows and m columns. The j-th symbol of the i-th row should be "." if the cell is empty at the start. Otherwise the j-th symbol of the i-th row should contain the only digit —- the answer modulo 10. The matrix should be printed without any spaces.
To make your output faster it is recommended to build the output as an array of n strings having length m and print it as a sequence of lines. It will be much faster than writing character-by-character.
As input/output can reach huge size it is recommended to use fast input/output methods: for example, prefer to use scanf/printf instead of cin/cout in C++, prefer to use BufferedReader/PrintWriter instead of Scanner/System.out in Java.
Input
The first line contains two integers n, m (1 ≤ n, m ≤ 1000) — the number of rows and columns in the field.
Each of the next n lines contains m symbols: "." for empty cells, "*" for impassable cells.
Output
Print the answer as a matrix as described above. See the examples to precise the format of the output.
Examples
Input
3 3
*.*
.*.
*.*
Output
3.3
.5.
3.3
Input
4 5
**..*
..***
.*.*.
*.*.*
Output
46..3
..732
.6.4.
5.4.3
Note
In first example, if we imagine that the central cell is empty then it will be included to component of size 5 (cross). If any of the corner cell will be empty then it will be included to component of size 3 (corner).
Submitted Solution:
```
def func(l,x,pos,n,m,dic):
if (pos[0],pos[1]) in dic:
return dic[(pos[0],pos[1])],dic
if l[pos[0]][pos[1]]=="*" or (pos[0],pos[1]) in x:
return x,dic
else:
x.add((pos[0],pos[1]))
if pos[0]<n-1:
x,dic = func(l,x,[pos[0]+1,pos[1]],n,m,dic)
if pos[1]<m-1:
x,dic = func(l,x,[pos[0],pos[1]+1],n,m,dic)
if pos[0]>0:
x,dic = func(l,x,[pos[0]-1,pos[1]],n,m,dic)
if pos[1]>0:
x,dic = func(l,x,[pos[0],pos[1]-1],n,m,dic)
for j in x:
dic[j] = x
return x,dic
n,m = map(int,input().split())
l = []
dic = {}
for _ in range(n):
temp = list(input())
l.append(temp)
v = set()
for i in range(n):
for j in range(m):
x = set()
x,dic = func(l,x,[i,j],n,m,dic)
for i in range(n):
s = ""
for j in range(m):
if l[i][j]=="*":
x = set()
if i<n-1 and (i+1,j) in dic:
x = set(list(x)+list(dic[(i+1,j)]))
if j<m-1 and (i,j+1) in dic:
x = set(list(x)+list(dic[(i,j+1)]))
if i>0 and (i-1,j) in dic:
x = set(list(x)+list(dic[(i-1,j)]))
if j>0 and (i,j-1) in dic:
x = set(list(x)+list(dic[(i,j-1)]))
s+=str(len(x)+1)
else:
s+="."
print(s)
``` | instruction | 0 | 26,057 | 23 | 52,114 |
No | output | 1 | 26,057 | 23 | 52,115 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
You are given a rectangular field of n × m cells. Each cell is either empty or impassable (contains an obstacle). Empty cells are marked with '.', impassable cells are marked with '*'. Let's call two empty cells adjacent if they share a side.
Let's call a connected component any non-extendible set of cells such that any two of them are connected by the path of adjacent cells. It is a typical well-known definition of a connected component.
For each impassable cell (x, y) imagine that it is an empty cell (all other cells remain unchanged) and find the size (the number of cells) of the connected component which contains (x, y). You should do it for each impassable cell independently.
The answer should be printed as a matrix with n rows and m columns. The j-th symbol of the i-th row should be "." if the cell is empty at the start. Otherwise the j-th symbol of the i-th row should contain the only digit —- the answer modulo 10. The matrix should be printed without any spaces.
To make your output faster it is recommended to build the output as an array of n strings having length m and print it as a sequence of lines. It will be much faster than writing character-by-character.
As input/output can reach huge size it is recommended to use fast input/output methods: for example, prefer to use scanf/printf instead of cin/cout in C++, prefer to use BufferedReader/PrintWriter instead of Scanner/System.out in Java.
Input
The first line contains two integers n, m (1 ≤ n, m ≤ 1000) — the number of rows and columns in the field.
Each of the next n lines contains m symbols: "." for empty cells, "*" for impassable cells.
Output
Print the answer as a matrix as described above. See the examples to precise the format of the output.
Examples
Input
3 3
*.*
.*.
*.*
Output
3.3
.5.
3.3
Input
4 5
**..*
..***
.*.*.
*.*.*
Output
46..3
..732
.6.4.
5.4.3
Note
In first example, if we imagine that the central cell is empty then it will be included to component of size 5 (cross). If any of the corner cell will be empty then it will be included to component of size 3 (corner).
Submitted Solution:
```
from sys import stdin,stdout
st=lambda:list(stdin.readline().strip())
li=lambda:list(map(int,stdin.readline().split()))
mp=lambda:map(int,stdin.readline().split())
inp=lambda:int(stdin.readline())
pr=lambda n: stdout.write(str(n)+"\n")
def valid(x,y):
if x>=n or y>=m or x<0 or y<0:
return False
if v[x][y] or l[x][y]=='*':
return False
return True
dx=[-1,1,0,0]
dy=[0,0,1,-1]
n,m=mp()
l=[st() for i in range(n)]
k=[list(i) for i in l]
for i in range(n):
for j in range(m):
if l[i][j]=='*':
v=[[False for i in range(m+1)] for j in range(n+1)]
ans=1
connected=[(i,j)]
stack=[(i,j)]
v[i][j]=True
while stack:
a,b=stack.pop()
for x in range(4):
newX,newY=a+dx[x], b+dy[x]
if valid(newX,newY):
stack.append((newX,newY))
v[newX][newY]=True
connected.append((newX,newY))
ans+=1
k[i][j]=ans
print('\n'.join([''.join([str(i) for i in j]) for j in k]))
``` | instruction | 0 | 26,058 | 23 | 52,116 |
No | output | 1 | 26,058 | 23 | 52,117 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
You are given a rectangular field of n × m cells. Each cell is either empty or impassable (contains an obstacle). Empty cells are marked with '.', impassable cells are marked with '*'. Let's call two empty cells adjacent if they share a side.
Let's call a connected component any non-extendible set of cells such that any two of them are connected by the path of adjacent cells. It is a typical well-known definition of a connected component.
For each impassable cell (x, y) imagine that it is an empty cell (all other cells remain unchanged) and find the size (the number of cells) of the connected component which contains (x, y). You should do it for each impassable cell independently.
The answer should be printed as a matrix with n rows and m columns. The j-th symbol of the i-th row should be "." if the cell is empty at the start. Otherwise the j-th symbol of the i-th row should contain the only digit —- the answer modulo 10. The matrix should be printed without any spaces.
To make your output faster it is recommended to build the output as an array of n strings having length m and print it as a sequence of lines. It will be much faster than writing character-by-character.
As input/output can reach huge size it is recommended to use fast input/output methods: for example, prefer to use scanf/printf instead of cin/cout in C++, prefer to use BufferedReader/PrintWriter instead of Scanner/System.out in Java.
Input
The first line contains two integers n, m (1 ≤ n, m ≤ 1000) — the number of rows and columns in the field.
Each of the next n lines contains m symbols: "." for empty cells, "*" for impassable cells.
Output
Print the answer as a matrix as described above. See the examples to precise the format of the output.
Examples
Input
3 3
*.*
.*.
*.*
Output
3.3
.5.
3.3
Input
4 5
**..*
..***
.*.*.
*.*.*
Output
46..3
..732
.6.4.
5.4.3
Note
In first example, if we imagine that the central cell is empty then it will be included to component of size 5 (cross). If any of the corner cell will be empty then it will be included to component of size 3 (corner).
Submitted Solution:
```
n,m=map(int,input().split())
a=[['*' for i in range(m+2)] for j in range(n+2)]
for i in range(1,n+1):
s=input()
for j in range(1,m+1): a[i][j]=s[j-1]
p=[0]*1000500
q=[0]*1000500
u=[0,0,1,-1]
v=[1,-1,0,0]
s=[[0 for i in range(m+2)] for j in range(n+2)]
t=[[0 for i in range(m+2)] for j in range(n+2)]
vis=[[0 for i in range(m+2)] for j in range(n+2)]
count=0
for i in range(1,n+1):
for j in range(1,m+1):
if a[i][j]=='.' and vis[i][j]==0:
l=0
r=1
p[1]=i
q[1]=j
vis[i][j]=1
while l<r:
l+=1
for I in range(4):
x=p[l]+u[I]
y=q[l]+v[I]
if a[x][y]=='.' and vis[x][y]==0:
r+=1
p[r]=x
q[r]=y
vis[x][y]=1
count+=1
for I in range(1,r+1):
s[p[I]][q[I]]=r
t[p[I]][q[I]]=count
for i in range(1,n+1):
for j in range(1,m+1):
if a[i][j]=='.':
print('.',end='')
else:
ans=0
for I in range(4):
flag=0
for J in range(I):
if t[i+u[I]][j+v[I]]==t[i+u[J]][j+v[J]]:
flag=1
if flag==0:
ans+=s[i+u[I]][j+v[I]]
print(ans+1,end='')
print()
``` | instruction | 0 | 26,059 | 23 | 52,118 |
No | output | 1 | 26,059 | 23 | 52,119 |
Provide tags and a correct Python 3 solution for this coding contest problem.
You are given a convex polygon P with n distinct vertices p1, p2, ..., pn. Vertex pi has coordinates (xi, yi) in the 2D plane. These vertices are listed in clockwise order.
You can choose a real number D and move each vertex of the polygon a distance of at most D from their original positions.
Find the maximum value of D such that no matter how you move the vertices, the polygon does not intersect itself and stays convex.
Input
The first line has one integer n (4 ≤ n ≤ 1 000) — the number of vertices.
The next n lines contain the coordinates of the vertices. Line i contains two integers xi and yi ( - 109 ≤ xi, yi ≤ 109) — the coordinates of the i-th vertex. These points are guaranteed to be given in clockwise order, and will form a strictly convex polygon (in particular, no three consecutive points lie on the same straight line).
Output
Print one real number D, which is the maximum real number such that no matter how you move the vertices, the polygon stays convex.
Your answer will be considered correct if its absolute or relative error does not exceed 10 - 6.
Namely, let's assume that your answer is a and the answer of the jury is b. The checker program will consider your answer correct if <image>.
Examples
Input
4
0 0
0 1
1 1
1 0
Output
0.3535533906
Input
6
5 0
10 0
12 -4
10 -8
5 -8
3 -4
Output
1.0000000000
Note
Here is a picture of the first sample
<image>
Here is an example of making the polygon non-convex.
<image>
This is not an optimal solution, since the maximum distance we moved one point is ≈ 0.4242640687, whereas we can make it non-convex by only moving each point a distance of at most ≈ 0.3535533906. | instruction | 0 | 26,136 | 23 | 52,272 |
Tags: geometry
Correct Solution:
```
def r(pred, cur, nxt):
x1, y1 = nxt['x'] - pred['x'], nxt['y'] - pred['y']
x2, y2 = cur['x'] - pred['x'], cur['y'] - pred['y']
m = abs(x1 * y2 - x2 * y1)
return m / (x1**2 + y1**2)**0.5
n = int(input())
a = []
for i in range(n):
x, y = (int(_) for _ in input().split())
a.append({'x': x, 'y': y})
min_r = r(a[-1], a[0], a[1]) / 2
for i in range(1, n):
min_r = min(min_r, r(a[i - 1], a[i], a[(i + 1) % n]) / 2)
print(min_r)
``` | output | 1 | 26,136 | 23 | 52,273 |
Provide tags and a correct Python 3 solution for this coding contest problem.
You are given a convex polygon P with n distinct vertices p1, p2, ..., pn. Vertex pi has coordinates (xi, yi) in the 2D plane. These vertices are listed in clockwise order.
You can choose a real number D and move each vertex of the polygon a distance of at most D from their original positions.
Find the maximum value of D such that no matter how you move the vertices, the polygon does not intersect itself and stays convex.
Input
The first line has one integer n (4 ≤ n ≤ 1 000) — the number of vertices.
The next n lines contain the coordinates of the vertices. Line i contains two integers xi and yi ( - 109 ≤ xi, yi ≤ 109) — the coordinates of the i-th vertex. These points are guaranteed to be given in clockwise order, and will form a strictly convex polygon (in particular, no three consecutive points lie on the same straight line).
Output
Print one real number D, which is the maximum real number such that no matter how you move the vertices, the polygon stays convex.
Your answer will be considered correct if its absolute or relative error does not exceed 10 - 6.
Namely, let's assume that your answer is a and the answer of the jury is b. The checker program will consider your answer correct if <image>.
Examples
Input
4
0 0
0 1
1 1
1 0
Output
0.3535533906
Input
6
5 0
10 0
12 -4
10 -8
5 -8
3 -4
Output
1.0000000000
Note
Here is a picture of the first sample
<image>
Here is an example of making the polygon non-convex.
<image>
This is not an optimal solution, since the maximum distance we moved one point is ≈ 0.4242640687, whereas we can make it non-convex by only moving each point a distance of at most ≈ 0.3535533906. | instruction | 0 | 26,137 | 23 | 52,274 |
Tags: geometry
Correct Solution:
```
from collections import Counter
n=int(input())
a=[]
for i in range(n):
a.append(list(map(int,input().split())))
#a.append(a[0])
m=10000000000
for i in range(-1,n-1):
b=a[i+1][0]-a[i-1][0]
c=a[i-1][1]-a[i+1][1]
d=-a[i-1][1]*b-a[i-1][0]*c
m=min(m,((a[i-1][0]-a[i][0])**2+(a[i-1][1]-a[i][1])**2)**0.5,\
((a[i+1][0]-a[i][0])**2+(a[i+1][1]-a[i][1])**2)**0.5,\
abs(b*a[i][1]+\
c*a[i][0]+\
d)/(b**2+c**2)**0.5)
print(m/2)
``` | output | 1 | 26,137 | 23 | 52,275 |
Provide tags and a correct Python 3 solution for this coding contest problem.
You are given a convex polygon P with n distinct vertices p1, p2, ..., pn. Vertex pi has coordinates (xi, yi) in the 2D plane. These vertices are listed in clockwise order.
You can choose a real number D and move each vertex of the polygon a distance of at most D from their original positions.
Find the maximum value of D such that no matter how you move the vertices, the polygon does not intersect itself and stays convex.
Input
The first line has one integer n (4 ≤ n ≤ 1 000) — the number of vertices.
The next n lines contain the coordinates of the vertices. Line i contains two integers xi and yi ( - 109 ≤ xi, yi ≤ 109) — the coordinates of the i-th vertex. These points are guaranteed to be given in clockwise order, and will form a strictly convex polygon (in particular, no three consecutive points lie on the same straight line).
Output
Print one real number D, which is the maximum real number such that no matter how you move the vertices, the polygon stays convex.
Your answer will be considered correct if its absolute or relative error does not exceed 10 - 6.
Namely, let's assume that your answer is a and the answer of the jury is b. The checker program will consider your answer correct if <image>.
Examples
Input
4
0 0
0 1
1 1
1 0
Output
0.3535533906
Input
6
5 0
10 0
12 -4
10 -8
5 -8
3 -4
Output
1.0000000000
Note
Here is a picture of the first sample
<image>
Here is an example of making the polygon non-convex.
<image>
This is not an optimal solution, since the maximum distance we moved one point is ≈ 0.4242640687, whereas we can make it non-convex by only moving each point a distance of at most ≈ 0.3535533906. | instruction | 0 | 26,138 | 23 | 52,276 |
Tags: geometry
Correct Solution:
```
def d(x, y, x1, y1, x2, y2):
if x1 == x2:
return abs(x - x1)
elif y1 == y2:
return abs(y - y1)
else:
return abs(((x-x1)/(x2-x1) - (y-y1)/(y2-y1)) / (1/(x2-x1)**2 + 1/(y2-y1)**2)**0.5)
def delta(a, b, c):
return d(a[0], a[1], b[0], b[1], c[0], c[1]) / 2
n = int(input())
data = [list(map(int, input().split())) for t in range(n)]
data.append(data[0])
data.append(data[1])
print(min(map(delta, data[1:], data, data[2:])))
``` | output | 1 | 26,138 | 23 | 52,277 |
Provide tags and a correct Python 3 solution for this coding contest problem.
You are given a convex polygon P with n distinct vertices p1, p2, ..., pn. Vertex pi has coordinates (xi, yi) in the 2D plane. These vertices are listed in clockwise order.
You can choose a real number D and move each vertex of the polygon a distance of at most D from their original positions.
Find the maximum value of D such that no matter how you move the vertices, the polygon does not intersect itself and stays convex.
Input
The first line has one integer n (4 ≤ n ≤ 1 000) — the number of vertices.
The next n lines contain the coordinates of the vertices. Line i contains two integers xi and yi ( - 109 ≤ xi, yi ≤ 109) — the coordinates of the i-th vertex. These points are guaranteed to be given in clockwise order, and will form a strictly convex polygon (in particular, no three consecutive points lie on the same straight line).
Output
Print one real number D, which is the maximum real number such that no matter how you move the vertices, the polygon stays convex.
Your answer will be considered correct if its absolute or relative error does not exceed 10 - 6.
Namely, let's assume that your answer is a and the answer of the jury is b. The checker program will consider your answer correct if <image>.
Examples
Input
4
0 0
0 1
1 1
1 0
Output
0.3535533906
Input
6
5 0
10 0
12 -4
10 -8
5 -8
3 -4
Output
1.0000000000
Note
Here is a picture of the first sample
<image>
Here is an example of making the polygon non-convex.
<image>
This is not an optimal solution, since the maximum distance we moved one point is ≈ 0.4242640687, whereas we can make it non-convex by only moving each point a distance of at most ≈ 0.3535533906. | instruction | 0 | 26,139 | 23 | 52,278 |
Tags: geometry
Correct Solution:
```
"""
ATSTNG's ejudge Python3 solution template
(actual solution is below)
"""
import sys, queue, string, math
try:
import dev_act_ffc429465ab634 # empty file in directory
DEV = True
except:
DEV = False
def log(*s):
if DEV: print('LOG', *s)
class EJudge:
def __init__(self, problem="default", reclim=1<<30):
self.problem = problem
sys.setrecursionlimit(reclim)
def use_files(self, infile='', outfile=''):
if infile!='':
self.infile = open(infile)
sys.stdin = self.infile
if infile!='':
self.outfile = open(outfile, 'w')
sys.stdout = self.outfile
def use_bacs_files(self):
self.use_files(self.problem+'.in', self.problem+'.out')
def get_tl(self):
while True: pass
def get_ml(self):
tmp = [[[5]*100000 for _ in range(1000)]]
while True: tmp.append([[5]*100000 for _ in range(1000)])
def get_re(self):
s = (0,)[8]
def get_wa(self, wstr='blablalblah'):
for _ in range(3): print(wstr)
exit()
class IntReader:
def __init__(self):
self.ost = queue.Queue()
def get(self):
return int(self.sget())
def sget(self):
if self.ost.empty():
for el in input().split():
self.ost.put(el)
return self.ost.get()
def release(self):
res = []
while not self.ost.empty():
res.append(self.ost.get())
return res
def tokenized(s):
""" Parses given string into tokens with default rules """
word = []
for ch in s.strip():
if ch == ' ':
if word: yield ''.join(word); word = []
elif 'a' <= ch <= 'z' or 'A' <= ch <= 'Z' or '0' <= ch <= '9':
word.append(ch)
else:
if word: yield ''.join(word); word = []
yield ch
if word: yield ''.join(word); word = []
###############################################################################
ej = EJudge( )
int_reader = IntReader()
fmap = lambda f,*l: list(map(f,*l))
parse_int = lambda: fmap(int, input().split())
def dist(a, b):
return math.sqrt( (a[0]-b[0])**2 + (a[1]-b[1])**2 )
def geron(la,lb,lc):
halfp = (la+lb+lc)/2
return math.sqrt(halfp*(halfp-la)*(halfp-lb)*(halfp-lc))
def oriented(a,b,c):
return abs((b[0] - a[0]) * (c[1] - a[1]) - (b[1] - a[1]) * (c[0] - a[0]))/2
def add_tria_desec(a, b, c):
global ans
la, lb, lc = dist(b,c), dist(c,a), dist(a,b)
s = oriented(a,b,c)
h = s*2/lb
dmax = h/2
ans = min(ans, dmax)
# input
n = int(input())
points = [parse_int() for _ in range(n)]
ans = 1<<32
for idx in range(-2, n-2):
log(idx, idx+1, idx+2)
add_tria_desec(points[idx], points[idx+1], points[idx+2], )
print(ans)
'''
4
-1000000000 -1000000000
-1000000000 1000000000
1000000000 1000000000
1000000000 -1000000000
4
0 0
10 3
5 0
3 -1
4
-1000000000 0
-1 1
1 1
1000000000 0
'''
``` | output | 1 | 26,139 | 23 | 52,279 |
Provide tags and a correct Python 3 solution for this coding contest problem.
You are given a convex polygon P with n distinct vertices p1, p2, ..., pn. Vertex pi has coordinates (xi, yi) in the 2D plane. These vertices are listed in clockwise order.
You can choose a real number D and move each vertex of the polygon a distance of at most D from their original positions.
Find the maximum value of D such that no matter how you move the vertices, the polygon does not intersect itself and stays convex.
Input
The first line has one integer n (4 ≤ n ≤ 1 000) — the number of vertices.
The next n lines contain the coordinates of the vertices. Line i contains two integers xi and yi ( - 109 ≤ xi, yi ≤ 109) — the coordinates of the i-th vertex. These points are guaranteed to be given in clockwise order, and will form a strictly convex polygon (in particular, no three consecutive points lie on the same straight line).
Output
Print one real number D, which is the maximum real number such that no matter how you move the vertices, the polygon stays convex.
Your answer will be considered correct if its absolute or relative error does not exceed 10 - 6.
Namely, let's assume that your answer is a and the answer of the jury is b. The checker program will consider your answer correct if <image>.
Examples
Input
4
0 0
0 1
1 1
1 0
Output
0.3535533906
Input
6
5 0
10 0
12 -4
10 -8
5 -8
3 -4
Output
1.0000000000
Note
Here is a picture of the first sample
<image>
Here is an example of making the polygon non-convex.
<image>
This is not an optimal solution, since the maximum distance we moved one point is ≈ 0.4242640687, whereas we can make it non-convex by only moving each point a distance of at most ≈ 0.3535533906. | instruction | 0 | 26,140 | 23 | 52,280 |
Tags: geometry
Correct Solution:
```
def calc(distance_1,distance_2,distance_3):
return ((2*distance_1*distance_3 + 2*distance_2*distance_3 - distance_3*distance_3 - (distance_1-distance_2)**2)/(16*distance_3))**0.5
def distance(point_1,point_2):
point_1,y1 = point_1
point_2,y2 = point_2
return (point_1-point_2)**2 + (y1-y2)**2
n = int(input().strip())
points = []
for _ in range(n):
points.append(tuple([int(x) for x in input().strip().split()]))
min_ = float("inf")
for i in range(n):
distance_1 = distance(points[i],points[(i+1)%n])
distance_2 = distance(points[(i+2)%n],points[(i+1)%n])
distance_3 = distance(points[(i+2)%n],points[i])
min_= min(min_,calc(distance_1,distance_2,distance_3))
print("%.9f"%(min_))
``` | output | 1 | 26,140 | 23 | 52,281 |
Provide tags and a correct Python 3 solution for this coding contest problem.
You are given a convex polygon P with n distinct vertices p1, p2, ..., pn. Vertex pi has coordinates (xi, yi) in the 2D plane. These vertices are listed in clockwise order.
You can choose a real number D and move each vertex of the polygon a distance of at most D from their original positions.
Find the maximum value of D such that no matter how you move the vertices, the polygon does not intersect itself and stays convex.
Input
The first line has one integer n (4 ≤ n ≤ 1 000) — the number of vertices.
The next n lines contain the coordinates of the vertices. Line i contains two integers xi and yi ( - 109 ≤ xi, yi ≤ 109) — the coordinates of the i-th vertex. These points are guaranteed to be given in clockwise order, and will form a strictly convex polygon (in particular, no three consecutive points lie on the same straight line).
Output
Print one real number D, which is the maximum real number such that no matter how you move the vertices, the polygon stays convex.
Your answer will be considered correct if its absolute or relative error does not exceed 10 - 6.
Namely, let's assume that your answer is a and the answer of the jury is b. The checker program will consider your answer correct if <image>.
Examples
Input
4
0 0
0 1
1 1
1 0
Output
0.3535533906
Input
6
5 0
10 0
12 -4
10 -8
5 -8
3 -4
Output
1.0000000000
Note
Here is a picture of the first sample
<image>
Here is an example of making the polygon non-convex.
<image>
This is not an optimal solution, since the maximum distance we moved one point is ≈ 0.4242640687, whereas we can make it non-convex by only moving each point a distance of at most ≈ 0.3535533906. | instruction | 0 | 26,141 | 23 | 52,282 |
Tags: geometry
Correct Solution:
```
d = lambda i, j: (t[i][0] - t[j % n][0]) ** 2 + (t[i][1] - t[j % n][1]) ** 2
n = int(input())
t = [list(map(int, input().split())) for q in range(n)]
h = 1e20
for i in range(n):
a, b, c = d(i - 1, i), d(i, i + 1), d(i - 1, i + 1)
h = min(h, (4 * a * b - (a + b - c) ** 2) / c)
print(h ** 0.5 / 4)
``` | output | 1 | 26,141 | 23 | 52,283 |
Provide tags and a correct Python 3 solution for this coding contest problem.
You are given a convex polygon P with n distinct vertices p1, p2, ..., pn. Vertex pi has coordinates (xi, yi) in the 2D plane. These vertices are listed in clockwise order.
You can choose a real number D and move each vertex of the polygon a distance of at most D from their original positions.
Find the maximum value of D such that no matter how you move the vertices, the polygon does not intersect itself and stays convex.
Input
The first line has one integer n (4 ≤ n ≤ 1 000) — the number of vertices.
The next n lines contain the coordinates of the vertices. Line i contains two integers xi and yi ( - 109 ≤ xi, yi ≤ 109) — the coordinates of the i-th vertex. These points are guaranteed to be given in clockwise order, and will form a strictly convex polygon (in particular, no three consecutive points lie on the same straight line).
Output
Print one real number D, which is the maximum real number such that no matter how you move the vertices, the polygon stays convex.
Your answer will be considered correct if its absolute or relative error does not exceed 10 - 6.
Namely, let's assume that your answer is a and the answer of the jury is b. The checker program will consider your answer correct if <image>.
Examples
Input
4
0 0
0 1
1 1
1 0
Output
0.3535533906
Input
6
5 0
10 0
12 -4
10 -8
5 -8
3 -4
Output
1.0000000000
Note
Here is a picture of the first sample
<image>
Here is an example of making the polygon non-convex.
<image>
This is not an optimal solution, since the maximum distance we moved one point is ≈ 0.4242640687, whereas we can make it non-convex by only moving each point a distance of at most ≈ 0.3535533906. | instruction | 0 | 26,142 | 23 | 52,284 |
Tags: geometry
Correct Solution:
```
n = int(input())
P = []
def h(p1, p2, m):
return abs(((p2[0] - p1[0])*(m[1] - p1[1])-(p2[1] - p1[1])*(m[0] - p1[0]))\
/((p2[0] - p1[0]) ** 2 + (p2[1] - p1[1])**2) ** 0.5)
for i in range(n):
P.append(list(map(int, input().split())))
answer = float("inf")
for i in range(n):
cw = P[(i + 1) % n]
ucw = P[i - 1]
answer = min(answer, h(cw, ucw, P[i])/2)
print(answer)
``` | output | 1 | 26,142 | 23 | 52,285 |
Provide tags and a correct Python 3 solution for this coding contest problem.
You are given a convex polygon P with n distinct vertices p1, p2, ..., pn. Vertex pi has coordinates (xi, yi) in the 2D plane. These vertices are listed in clockwise order.
You can choose a real number D and move each vertex of the polygon a distance of at most D from their original positions.
Find the maximum value of D such that no matter how you move the vertices, the polygon does not intersect itself and stays convex.
Input
The first line has one integer n (4 ≤ n ≤ 1 000) — the number of vertices.
The next n lines contain the coordinates of the vertices. Line i contains two integers xi and yi ( - 109 ≤ xi, yi ≤ 109) — the coordinates of the i-th vertex. These points are guaranteed to be given in clockwise order, and will form a strictly convex polygon (in particular, no three consecutive points lie on the same straight line).
Output
Print one real number D, which is the maximum real number such that no matter how you move the vertices, the polygon stays convex.
Your answer will be considered correct if its absolute or relative error does not exceed 10 - 6.
Namely, let's assume that your answer is a and the answer of the jury is b. The checker program will consider your answer correct if <image>.
Examples
Input
4
0 0
0 1
1 1
1 0
Output
0.3535533906
Input
6
5 0
10 0
12 -4
10 -8
5 -8
3 -4
Output
1.0000000000
Note
Here is a picture of the first sample
<image>
Here is an example of making the polygon non-convex.
<image>
This is not an optimal solution, since the maximum distance we moved one point is ≈ 0.4242640687, whereas we can make it non-convex by only moving each point a distance of at most ≈ 0.3535533906. | instruction | 0 | 26,143 | 23 | 52,286 |
Tags: geometry
Correct Solution:
```
from sys import stdin, stdout
import math
n = int(stdin.readline().rstrip())
pointsList=[]
for i in range(n):
x,y = map(int, stdin.readline().rstrip().split())
pointsList.append((x,y))
maxD=999999999999999
for i in range(n):
if i==n-2:
j=n-1
k=0
elif i==n-1:
j=0
k=1
else:
j=i+1
k=i+2
p1x,p1y = pointsList[i] # how much we need to translate by
p3x,p3y = pointsList[k]
p3x-=p1x; p3y-=p1y # Translate the third points
theta = math.atan2(p3y,p3x)
p2x,p2y = pointsList[j]
p2x-=p1x; p2y-=p1y # Translate the second points
y = - p2x * math.sin(theta) + p2y * math.cos(theta)
maxD = min(y/2,maxD)
print(maxD)
``` | output | 1 | 26,143 | 23 | 52,287 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
You are given a convex polygon P with n distinct vertices p1, p2, ..., pn. Vertex pi has coordinates (xi, yi) in the 2D plane. These vertices are listed in clockwise order.
You can choose a real number D and move each vertex of the polygon a distance of at most D from their original positions.
Find the maximum value of D such that no matter how you move the vertices, the polygon does not intersect itself and stays convex.
Input
The first line has one integer n (4 ≤ n ≤ 1 000) — the number of vertices.
The next n lines contain the coordinates of the vertices. Line i contains two integers xi and yi ( - 109 ≤ xi, yi ≤ 109) — the coordinates of the i-th vertex. These points are guaranteed to be given in clockwise order, and will form a strictly convex polygon (in particular, no three consecutive points lie on the same straight line).
Output
Print one real number D, which is the maximum real number such that no matter how you move the vertices, the polygon stays convex.
Your answer will be considered correct if its absolute or relative error does not exceed 10 - 6.
Namely, let's assume that your answer is a and the answer of the jury is b. The checker program will consider your answer correct if <image>.
Examples
Input
4
0 0
0 1
1 1
1 0
Output
0.3535533906
Input
6
5 0
10 0
12 -4
10 -8
5 -8
3 -4
Output
1.0000000000
Note
Here is a picture of the first sample
<image>
Here is an example of making the polygon non-convex.
<image>
This is not an optimal solution, since the maximum distance we moved one point is ≈ 0.4242640687, whereas we can make it non-convex by only moving each point a distance of at most ≈ 0.3535533906.
Submitted Solution:
```
#!/usr/bin/env python3
import math
def dist(a, b):
x1, y1 = a
x2, y2 = b
return math.sqrt((x1-x2)**2+(y1-y2)**2)
def minh(a, b, c):
m = dist(a, b)
n = dist(b, c)
k = dist(a, c)
p = (m + n + k)/2
sqp = math.sqrt(p*(p-m)*(p-n)*(p-k))
hm = (2/m)*sqp
hn = (2/n)*sqp
hk = (2/k)*sqp
return min([hm, hn, hk])
def solve():
n = int(input())
coords = []
for i in range(n):
coords.append(tuple(map(int, input().split())))
coords += [coords[0], coords[1]]
res = min(
minh(coords[i], coords[i+1], coords[i+2])
for i in range(n))
print("%.10f" % (res/2))
if __name__ == '__main__':
solve()
``` | instruction | 0 | 26,144 | 23 | 52,288 |
No | output | 1 | 26,144 | 23 | 52,289 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
You are given a convex polygon P with n distinct vertices p1, p2, ..., pn. Vertex pi has coordinates (xi, yi) in the 2D plane. These vertices are listed in clockwise order.
You can choose a real number D and move each vertex of the polygon a distance of at most D from their original positions.
Find the maximum value of D such that no matter how you move the vertices, the polygon does not intersect itself and stays convex.
Input
The first line has one integer n (4 ≤ n ≤ 1 000) — the number of vertices.
The next n lines contain the coordinates of the vertices. Line i contains two integers xi and yi ( - 109 ≤ xi, yi ≤ 109) — the coordinates of the i-th vertex. These points are guaranteed to be given in clockwise order, and will form a strictly convex polygon (in particular, no three consecutive points lie on the same straight line).
Output
Print one real number D, which is the maximum real number such that no matter how you move the vertices, the polygon stays convex.
Your answer will be considered correct if its absolute or relative error does not exceed 10 - 6.
Namely, let's assume that your answer is a and the answer of the jury is b. The checker program will consider your answer correct if <image>.
Examples
Input
4
0 0
0 1
1 1
1 0
Output
0.3535533906
Input
6
5 0
10 0
12 -4
10 -8
5 -8
3 -4
Output
1.0000000000
Note
Here is a picture of the first sample
<image>
Here is an example of making the polygon non-convex.
<image>
This is not an optimal solution, since the maximum distance we moved one point is ≈ 0.4242640687, whereas we can make it non-convex by only moving each point a distance of at most ≈ 0.3535533906.
Submitted Solution:
```
d = lambda i, j: (t[i][0] - t[j % n][0]) ** 2 + (t[i][1] - t[j % n][1]) ** 2
n = int(input())
t = [list(map(int, input().split())) for q in range(n)]
h = 1e9
for i in range(n):
a, b, c = d(i - 1, i), d(i, i + 1), d(i - 1, i + 1)
h = min(h, 4 * a - (a + c - b) ** 2 // c)
print(h ** 0.5 / 4)
``` | instruction | 0 | 26,145 | 23 | 52,290 |
No | output | 1 | 26,145 | 23 | 52,291 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
You are given a convex polygon P with n distinct vertices p1, p2, ..., pn. Vertex pi has coordinates (xi, yi) in the 2D plane. These vertices are listed in clockwise order.
You can choose a real number D and move each vertex of the polygon a distance of at most D from their original positions.
Find the maximum value of D such that no matter how you move the vertices, the polygon does not intersect itself and stays convex.
Input
The first line has one integer n (4 ≤ n ≤ 1 000) — the number of vertices.
The next n lines contain the coordinates of the vertices. Line i contains two integers xi and yi ( - 109 ≤ xi, yi ≤ 109) — the coordinates of the i-th vertex. These points are guaranteed to be given in clockwise order, and will form a strictly convex polygon (in particular, no three consecutive points lie on the same straight line).
Output
Print one real number D, which is the maximum real number such that no matter how you move the vertices, the polygon stays convex.
Your answer will be considered correct if its absolute or relative error does not exceed 10 - 6.
Namely, let's assume that your answer is a and the answer of the jury is b. The checker program will consider your answer correct if <image>.
Examples
Input
4
0 0
0 1
1 1
1 0
Output
0.3535533906
Input
6
5 0
10 0
12 -4
10 -8
5 -8
3 -4
Output
1.0000000000
Note
Here is a picture of the first sample
<image>
Here is an example of making the polygon non-convex.
<image>
This is not an optimal solution, since the maximum distance we moved one point is ≈ 0.4242640687, whereas we can make it non-convex by only moving each point a distance of at most ≈ 0.3535533906.
Submitted Solution:
```
d = lambda i, j: (t[i][0] - t[j % n][0]) ** 2 + (t[i][1] - t[j % n][1]) ** 2
n = int(input())
t = [list(map(int, input().split())) for q in range(n)]
h = 1e13
for i in range(n):
a, b, c = d(i - 1, i), d(i, i + 1), d(i - 1, i + 1)
h = min(h, (4 * a * b - (a + b - c) ** 2) / c)
print(h ** 0.5 / 4)
``` | instruction | 0 | 26,146 | 23 | 52,292 |
No | output | 1 | 26,146 | 23 | 52,293 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
You are given a convex polygon P with n distinct vertices p1, p2, ..., pn. Vertex pi has coordinates (xi, yi) in the 2D plane. These vertices are listed in clockwise order.
You can choose a real number D and move each vertex of the polygon a distance of at most D from their original positions.
Find the maximum value of D such that no matter how you move the vertices, the polygon does not intersect itself and stays convex.
Input
The first line has one integer n (4 ≤ n ≤ 1 000) — the number of vertices.
The next n lines contain the coordinates of the vertices. Line i contains two integers xi and yi ( - 109 ≤ xi, yi ≤ 109) — the coordinates of the i-th vertex. These points are guaranteed to be given in clockwise order, and will form a strictly convex polygon (in particular, no three consecutive points lie on the same straight line).
Output
Print one real number D, which is the maximum real number such that no matter how you move the vertices, the polygon stays convex.
Your answer will be considered correct if its absolute or relative error does not exceed 10 - 6.
Namely, let's assume that your answer is a and the answer of the jury is b. The checker program will consider your answer correct if <image>.
Examples
Input
4
0 0
0 1
1 1
1 0
Output
0.3535533906
Input
6
5 0
10 0
12 -4
10 -8
5 -8
3 -4
Output
1.0000000000
Note
Here is a picture of the first sample
<image>
Here is an example of making the polygon non-convex.
<image>
This is not an optimal solution, since the maximum distance we moved one point is ≈ 0.4242640687, whereas we can make it non-convex by only moving each point a distance of at most ≈ 0.3535533906.
Submitted Solution:
```
d = lambda i, j: (t[i][0] - t[j % n][0]) ** 2 + (t[i][1] - t[j % n][1]) ** 2
n = int(input())
t = [list(map(int, input().split())) for q in range(n)]
h = 1e9
for i in range(n):
a, b, c = d(i - 1, i), d(i, i + 1), d(i - 1, i + 1)
h = min(h, (4 * a * b - (a + b - c) ** 2) / c)
print(h ** 0.5 / 4)
``` | instruction | 0 | 26,147 | 23 | 52,294 |
No | output | 1 | 26,147 | 23 | 52,295 |
Provide a correct Python 3 solution for this coding contest problem.
We have a grid with (2^N - 1) rows and (2^M-1) columns. You are asked to write 0 or 1 in each of these squares. Let a_{i,j} be the number written in the square at the i-th row from the top and the j-th column from the left.
For a quadruple of integers (i_1, i_2, j_1, j_2) such that 1\leq i_1 \leq i_2\leq 2^N-1, 1\leq j_1 \leq j_2\leq 2^M-1, let S(i_1, i_2, j_1, j_2) = \displaystyle \sum_{r=i_1}^{i_2}\sum_{c=j_1}^{j_2}a_{r,c}. Then, let the oddness of the grid be the number of quadruples (i_1, i_2, j_1, j_2) such that S(i_1, i_2, j_1, j_2) is odd.
Find a way to fill in the grid that maximizes its oddness.
Constraints
* N and M are integers between 1 and 10 (inclusive).
Input
Input is given from Standard Input in the following format:
N M
Output
Print numbers to write in the grid so that its oddness is maximized, in the following format:
a_{1,1}a_{1,2}\cdots a_{1,2^M-1}
a_{2,1}a_{2,2}\cdots a_{2,2^M-1}
\vdots
a_{2^N-1,1}a_{2^N-1,2}\cdots a_{2^N-1,2^M-1}
If there are multiple solutions, you can print any of them.
Example
Input
1 2
Output
111 | instruction | 0 | 26,251 | 23 | 52,502 |
"Correct Solution:
```
N,M=map(int,input().split())
A=[]
for i in range(2**N):
B=[]
for j in range(2**M):
B.append(bin(i&j).count("1")%2)
A.append(B)
ANS=[[0]*(2**M) for i in range(2**N)]
for i in range(1,2**N):
for j in range(1,2**M):
if A[i][j]!=(A[i-1][j]+A[i][j-1]-A[i-1][j-1])%2:
ANS[i][j]=1
for a in ANS[1:]:
print("".join(map(str,a[1:])))
``` | output | 1 | 26,251 | 23 | 52,503 |
Provide a correct Python 3 solution for this coding contest problem.
We have a grid with (2^N - 1) rows and (2^M-1) columns. You are asked to write 0 or 1 in each of these squares. Let a_{i,j} be the number written in the square at the i-th row from the top and the j-th column from the left.
For a quadruple of integers (i_1, i_2, j_1, j_2) such that 1\leq i_1 \leq i_2\leq 2^N-1, 1\leq j_1 \leq j_2\leq 2^M-1, let S(i_1, i_2, j_1, j_2) = \displaystyle \sum_{r=i_1}^{i_2}\sum_{c=j_1}^{j_2}a_{r,c}. Then, let the oddness of the grid be the number of quadruples (i_1, i_2, j_1, j_2) such that S(i_1, i_2, j_1, j_2) is odd.
Find a way to fill in the grid that maximizes its oddness.
Constraints
* N and M are integers between 1 and 10 (inclusive).
Input
Input is given from Standard Input in the following format:
N M
Output
Print numbers to write in the grid so that its oddness is maximized, in the following format:
a_{1,1}a_{1,2}\cdots a_{1,2^M-1}
a_{2,1}a_{2,2}\cdots a_{2,2^M-1}
\vdots
a_{2^N-1,1}a_{2^N-1,2}\cdots a_{2^N-1,2^M-1}
If there are multiple solutions, you can print any of them.
Example
Input
1 2
Output
111 | instruction | 0 | 26,252 | 23 | 52,504 |
"Correct Solution:
```
n,m=map(int,input().split())
ans=[["1"]*(2**m-1) for _ in range(2**n-1)]
for k in range(1,11):
for i in range(2**k,2**n,2**k):
for j in range(2**k,2**m,2**k):
if ans[i-1][j-1]=="1":
ans[i-1][j-1]="0"
else:
ans[i-1][j-1]="1"
for i in range(2**n-1):
print("".join(ans[i]))
``` | output | 1 | 26,252 | 23 | 52,505 |
Provide a correct Python 3 solution for this coding contest problem.
We have a grid with (2^N - 1) rows and (2^M-1) columns. You are asked to write 0 or 1 in each of these squares. Let a_{i,j} be the number written in the square at the i-th row from the top and the j-th column from the left.
For a quadruple of integers (i_1, i_2, j_1, j_2) such that 1\leq i_1 \leq i_2\leq 2^N-1, 1\leq j_1 \leq j_2\leq 2^M-1, let S(i_1, i_2, j_1, j_2) = \displaystyle \sum_{r=i_1}^{i_2}\sum_{c=j_1}^{j_2}a_{r,c}. Then, let the oddness of the grid be the number of quadruples (i_1, i_2, j_1, j_2) such that S(i_1, i_2, j_1, j_2) is odd.
Find a way to fill in the grid that maximizes its oddness.
Constraints
* N and M are integers between 1 and 10 (inclusive).
Input
Input is given from Standard Input in the following format:
N M
Output
Print numbers to write in the grid so that its oddness is maximized, in the following format:
a_{1,1}a_{1,2}\cdots a_{1,2^M-1}
a_{2,1}a_{2,2}\cdots a_{2,2^M-1}
\vdots
a_{2^N-1,1}a_{2^N-1,2}\cdots a_{2^N-1,2^M-1}
If there are multiple solutions, you can print any of them.
Example
Input
1 2
Output
111 | instruction | 0 | 26,253 | 23 | 52,506 |
"Correct Solution:
```
#!usr/bin/env python3
from collections import defaultdict,deque
from heapq import heappush, heappop
from itertools import permutations
import sys
import math
import bisect
def LI(): return [int(x) for x in sys.stdin.readline().split()]
def I(): return int(sys.stdin.readline())
def LS():return [list(x) for x in sys.stdin.readline().split()]
def S():
res = list(sys.stdin.readline())
if res[-1] == "\n":
return res[:-1]
return res
def IR(n):
return [I() for i in range(n)]
def LIR(n):
return [LI() for i in range(n)]
def SR(n):
return [S() for i in range(n)]
def LSR(n):
return [LS() for i in range(n)]
sys.setrecursionlimit(1000000)
mod = 1000000007
def solve():
def hadamard(n):
if mem[n] != None:
return mem[n]
h = hadamard(n-1)
res = [[j for j in i] for i in h]
res_ = [[j for j in i] for i in h]
for i in range(len(res)):
res[i] += [j for j in h[i]]
res_[i] += [j^1 for j in h[i]]
res += res_
mem[n] = res
return res
n,m = LI()
f = 0
if m < n:
n,m = m,n
f = 1
h,w = 1<<n, 1<<m
mem = defaultdict(lambda : None)
mem[0] = [[0]]
s = hadamard(m)[:h]
if f:
s = [[s[j][i] for j in range(h)] for i in range(w)]
h,w = w,h
for x in range(w):
for y in range(h-1)[::-1]:
s[y+1][x] ^= s[y][x]
for y in range(h):
for x in range(w-1)[::-1]:
s[y][x+1] ^= s[y][x]
ans = [i[1:] for i in s[1:]]
for i in ans:
print(*i,sep="")
return
#Solve
if __name__ == "__main__":
solve()
``` | output | 1 | 26,253 | 23 | 52,507 |
Provide a correct Python 3 solution for this coding contest problem.
We have a grid with (2^N - 1) rows and (2^M-1) columns. You are asked to write 0 or 1 in each of these squares. Let a_{i,j} be the number written in the square at the i-th row from the top and the j-th column from the left.
For a quadruple of integers (i_1, i_2, j_1, j_2) such that 1\leq i_1 \leq i_2\leq 2^N-1, 1\leq j_1 \leq j_2\leq 2^M-1, let S(i_1, i_2, j_1, j_2) = \displaystyle \sum_{r=i_1}^{i_2}\sum_{c=j_1}^{j_2}a_{r,c}. Then, let the oddness of the grid be the number of quadruples (i_1, i_2, j_1, j_2) such that S(i_1, i_2, j_1, j_2) is odd.
Find a way to fill in the grid that maximizes its oddness.
Constraints
* N and M are integers between 1 and 10 (inclusive).
Input
Input is given from Standard Input in the following format:
N M
Output
Print numbers to write in the grid so that its oddness is maximized, in the following format:
a_{1,1}a_{1,2}\cdots a_{1,2^M-1}
a_{2,1}a_{2,2}\cdots a_{2,2^M-1}
\vdots
a_{2^N-1,1}a_{2^N-1,2}\cdots a_{2^N-1,2^M-1}
If there are multiple solutions, you can print any of them.
Example
Input
1 2
Output
111 | instruction | 0 | 26,254 | 23 | 52,508 |
"Correct Solution:
```
import sys
bitcnt = [0] * (1 << 10)
for i in range(1,1 << 10):
bitcnt[i] = bitcnt[i//2] + i % 2
bitcnt[i] %= 2
field = [[bitcnt[i & j] for j in range(1 << 10)] for i in range(1 << 10)]
n, m = map(int, input().split())
n = 1 << n
m = 1 << m
for i in range(1, n):
for j in range(1, m):
num = field[i][j] - field[i-1][j-1] - field[i-1][j] -field[i][j-1]
sys.stdout.write(str(num%2))
print()
``` | output | 1 | 26,254 | 23 | 52,509 |
Provide a correct Python 3 solution for this coding contest problem.
We have a grid with (2^N - 1) rows and (2^M-1) columns. You are asked to write 0 or 1 in each of these squares. Let a_{i,j} be the number written in the square at the i-th row from the top and the j-th column from the left.
For a quadruple of integers (i_1, i_2, j_1, j_2) such that 1\leq i_1 \leq i_2\leq 2^N-1, 1\leq j_1 \leq j_2\leq 2^M-1, let S(i_1, i_2, j_1, j_2) = \displaystyle \sum_{r=i_1}^{i_2}\sum_{c=j_1}^{j_2}a_{r,c}. Then, let the oddness of the grid be the number of quadruples (i_1, i_2, j_1, j_2) such that S(i_1, i_2, j_1, j_2) is odd.
Find a way to fill in the grid that maximizes its oddness.
Constraints
* N and M are integers between 1 and 10 (inclusive).
Input
Input is given from Standard Input in the following format:
N M
Output
Print numbers to write in the grid so that its oddness is maximized, in the following format:
a_{1,1}a_{1,2}\cdots a_{1,2^M-1}
a_{2,1}a_{2,2}\cdots a_{2,2^M-1}
\vdots
a_{2^N-1,1}a_{2^N-1,2}\cdots a_{2^N-1,2^M-1}
If there are multiple solutions, you can print any of them.
Example
Input
1 2
Output
111 | instruction | 0 | 26,255 | 23 | 52,510 |
"Correct Solution:
```
n, m = map(int, input().split())
ans = [0, 1]
for i in range(1, min(n, m)):
k = 1 << i
x = (1 << k) - 1
slide = [a << k for a in ans]
new_ans = [s | a for s, a in zip(slide, ans)]
new_ans.extend(s | (a ^ x) for s, a in zip(slide, ans))
ans = new_ans
if n > m:
ans *= 1 << (n - m)
elif n < m:
for i in range(n, m):
k = 1 << i
ans = [(a << k) | a for a in ans]
ans = [a0 ^ a1 for a0, a1 in zip(ans, ans[1:])]
ans = [a ^ (a >> 1) for a in ans]
print('\n'.join(map(('{:0' + str(2 ** m - 1) + 'b}').format, ans)))
``` | output | 1 | 26,255 | 23 | 52,511 |
Provide a correct Python 3 solution for this coding contest problem.
We have a grid with (2^N - 1) rows and (2^M-1) columns. You are asked to write 0 or 1 in each of these squares. Let a_{i,j} be the number written in the square at the i-th row from the top and the j-th column from the left.
For a quadruple of integers (i_1, i_2, j_1, j_2) such that 1\leq i_1 \leq i_2\leq 2^N-1, 1\leq j_1 \leq j_2\leq 2^M-1, let S(i_1, i_2, j_1, j_2) = \displaystyle \sum_{r=i_1}^{i_2}\sum_{c=j_1}^{j_2}a_{r,c}. Then, let the oddness of the grid be the number of quadruples (i_1, i_2, j_1, j_2) such that S(i_1, i_2, j_1, j_2) is odd.
Find a way to fill in the grid that maximizes its oddness.
Constraints
* N and M are integers between 1 and 10 (inclusive).
Input
Input is given from Standard Input in the following format:
N M
Output
Print numbers to write in the grid so that its oddness is maximized, in the following format:
a_{1,1}a_{1,2}\cdots a_{1,2^M-1}
a_{2,1}a_{2,2}\cdots a_{2,2^M-1}
\vdots
a_{2^N-1,1}a_{2^N-1,2}\cdots a_{2^N-1,2^M-1}
If there are multiple solutions, you can print any of them.
Example
Input
1 2
Output
111 | instruction | 0 | 26,256 | 23 | 52,512 |
"Correct Solution:
```
# coding: utf-8
# Your code here!
import sys
sys.setrecursionlimit(10**6)
readline = sys.stdin.readline
read = sys.stdin.read
n,m = [int(i) for i in read().split()]
def popcount(i): # i < 2^32
i = i - ((i >> 1) & 0x55555555)
i = (i & 0x33333333) + ((i >> 2) & 0x33333333)
return (((i + (i >> 4) & 0xF0F0F0F) * 0x1010101) & 0xffffffff) >> 24
N = 2**n
M = 2**m
a = []
for k in range(N):
a.append([popcount(x&k)&1 for x in range(M)])
#print(a)
for i in range(N-1,0,-1):
for j in range(M-1,0,-1):
a[i][j] ^= a[i-1][j]^a[i][j-1]^a[i-1][j-1]
for i in range(1,N):
x = map(str,a[i][1:])
print("".join(x))
``` | output | 1 | 26,256 | 23 | 52,513 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
We have a grid with (2^N - 1) rows and (2^M-1) columns. You are asked to write 0 or 1 in each of these squares. Let a_{i,j} be the number written in the square at the i-th row from the top and the j-th column from the left.
For a quadruple of integers (i_1, i_2, j_1, j_2) such that 1\leq i_1 \leq i_2\leq 2^N-1, 1\leq j_1 \leq j_2\leq 2^M-1, let S(i_1, i_2, j_1, j_2) = \displaystyle \sum_{r=i_1}^{i_2}\sum_{c=j_1}^{j_2}a_{r,c}. Then, let the oddness of the grid be the number of quadruples (i_1, i_2, j_1, j_2) such that S(i_1, i_2, j_1, j_2) is odd.
Find a way to fill in the grid that maximizes its oddness.
Constraints
* N and M are integers between 1 and 10 (inclusive).
Input
Input is given from Standard Input in the following format:
N M
Output
Print numbers to write in the grid so that its oddness is maximized, in the following format:
a_{1,1}a_{1,2}\cdots a_{1,2^M-1}
a_{2,1}a_{2,2}\cdots a_{2,2^M-1}
\vdots
a_{2^N-1,1}a_{2^N-1,2}\cdots a_{2^N-1,2^M-1}
If there are multiple solutions, you can print any of them.
Example
Input
1 2
Output
111
Submitted Solution:
```
n, m = map(int, input().split())
for i in range(2 ** n - 1):
print('1' * (2 ** m - 1))
``` | instruction | 0 | 26,257 | 23 | 52,514 |
No | output | 1 | 26,257 | 23 | 52,515 |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.