message stringlengths 2 44.5k | message_type stringclasses 2 values | message_id int64 0 1 | conversation_id int64 276 109k | cluster float64 23 23 | __index_level_0__ int64 552 217k |
|---|---|---|---|---|---|
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
A 3Γ3 grid with a integer written in each square, is called a magic square if and only if the integers in each row, the integers in each column, and the integers in each diagonal (from the top left corner to the bottom right corner, and from the top right corner to the bottom left corner), all add up to the same sum.
You are given the integers written in the following three squares in a magic square:
* The integer A at the upper row and left column
* The integer B at the upper row and middle column
* The integer C at the middle row and middle column
Determine the integers written in the remaining squares in the magic square.
It can be shown that there exists a unique magic square consistent with the given information.
Constraints
* 0 \leq A, B, C \leq 100
Input
The input is given from Standard Input in the following format:
A
B
C
Output
Output the integers written in the magic square, in the following format:
X_{1,1} X_{1,2} X_{1,3}
X_{2,1} X_{2,2} X_{2,3}
X_{3,1} X_{3,2} X_{3,3}
where X_{i,j} is the integer written in the square at the i-th row and j-th column.
Examples
Input
8
3
5
Output
8 3 4
1 5 9
6 7 2
Input
1
1
1
Output
1 1 1
1 1 1
1 1 1
Submitted Solution:
```
a=int(input())
b=int(input())
c=int(input())
x=[[0,0,0] for _ in range(3)]
for i in range(3,301):
x[0][0]=a
x[0][1]=b
x[1][1]=c
x[0][2]=i-a-b
x[2][2]=i-a-c
x[2][1]=i-b-c
x[1][2]=i-x[0][2]-x[2][2]
x[1][0]=i-c-x[1][2]
x[2][0]=i-x[2][1]-x[2][2]
ok = True
for j in range(3):
for k in range(3):
ok = ok and (1 <= x[j][k] <= 100)
if not ok:
continue
for j in range(3):
print(x[j][0],x[j][1],x[j][2])
exit(0)
``` | instruction | 0 | 92,514 | 23 | 185,028 |
No | output | 1 | 92,514 | 23 | 185,029 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
A 3Γ3 grid with a integer written in each square, is called a magic square if and only if the integers in each row, the integers in each column, and the integers in each diagonal (from the top left corner to the bottom right corner, and from the top right corner to the bottom left corner), all add up to the same sum.
You are given the integers written in the following three squares in a magic square:
* The integer A at the upper row and left column
* The integer B at the upper row and middle column
* The integer C at the middle row and middle column
Determine the integers written in the remaining squares in the magic square.
It can be shown that there exists a unique magic square consistent with the given information.
Constraints
* 0 \leq A, B, C \leq 100
Input
The input is given from Standard Input in the following format:
A
B
C
Output
Output the integers written in the magic square, in the following format:
X_{1,1} X_{1,2} X_{1,3}
X_{2,1} X_{2,2} X_{2,3}
X_{3,1} X_{3,2} X_{3,3}
where X_{i,j} is the integer written in the square at the i-th row and j-th column.
Examples
Input
8
3
5
Output
8 3 4
1 5 9
6 7 2
Input
1
1
1
Output
1 1 1
1 1 1
1 1 1
Submitted Solution:
```
# -*- coding: utf-8 -*-
def main():
a = int(input())
b = int(input())
c = int(input())
# a b e
# g c i
# h d f
for total in range(1000 + 1):
d = total - (b + c)
e = total - (a + b)
f = total - (a + c)
if 0 <= d and 0 <= e and 0 <= f:
i = total - (e + f)
h = total - (e + c)
g = total - (a + h)
if 0 <= i and 0 <= h and 0 <= g:
if total == (d + f + h):
print(a, b, e)
print(g, c, i)
print(h, d, f)
exit()
if __name__ == '__main__':
main()
``` | instruction | 0 | 92,515 | 23 | 185,030 |
No | output | 1 | 92,515 | 23 | 185,031 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
The following sorting operation is repeated for the stacked blocks as shown in Fig. A.
1. Stack all the bottom blocks (white blocks in Figure a) on the right edge (the remaining blocks will automatically drop one step down, as shown in Figure b).
2. If there is a gap between the blocks, pack it to the left to eliminate the gap (from Fig. B to Fig. C).
For an integer k greater than or equal to 1, a number represented by k Γ (k + 1) / 2 (example: 1, 3, 6, 10, ...) is called a triangular number. If the total number of blocks is a triangular number, it is expected that if the above sorting is repeated, the height of the left end will be 1 and the total number will increase by 1 toward the right (Fig. D shows the total number). For 15).
<image>
When the first sequence of blocks is given, when the triangle of the block as explained above is created by the operation less than the predetermined number of times, create a program that outputs the minimum number of operations until the triangle is obtained. please.
input
The input consists of multiple datasets. The end of the input is indicated by a single zero line. Each dataset is given in the following format.
N
b1 b2 ... bN
Each dataset has two rows and represents the first sequence of blocks. N (1 β€ N β€ 100) indicates the number of blocks in the bottom row. bi (1 β€ bi β€ 10000) indicates the number of blocks stacked in the i-th position from the left. bi and bi + 1 are separated by a single space. The total number of blocks is 3 or more.
The number of datasets does not exceed 20.
output
For each data set, the number of sorting operations performed until the triangle is formed is output on one line. However, if a triangle cannot be created or the number of operations exceeds 10000, -1 is output.
Example
Input
6
1 4 1 3 2 4
5
1 2 3 4 5
10
1 1 1 1 1 1 1 1 1 1
9
1 1 1 1 1 1 1 1 1
12
1 4 1 3 2 4 3 3 2 1 2 2
1
5050
3
10000 10000 100
0
Output
24
0
10
-1
48
5049
-1
Submitted Solution:
```
while 1:
N = int(input())
if N == 0:break
lst = list(map(int,input().split()))
s_len = 1
n = lst[-1]
# for v in reversed(lst[:-1]):
# if v == n-1:
# s_len += 1
# n -= 1
# else:
# break
result = -1
for i in range(10000):
flg = True
for j in range(len(lst)):
if j+1 != lst[j]:
flg = False
if flg:
result = i
break
# if len(lst) == s_len:
# result = i
# break
#ζγγγγγ―ζ°γεεΎ
cnt = 0
for j in reversed(range(len(lst))):
cnt += 1
lst[j] -= 1
if lst[j] == 0:
# if j >= len(lst)-s_len:
# s_len -=1
# elif j == len(lst)-s_len-1 and j > 0 and s_len > 0:
# if lst[j-1] ==lst[len(lst)-s_len]:
# s_len += 1
lst.pop(j)
lst.append(cnt)
# print(lst)
# if cnt == lst[-2]+1:
# s_len += 1
# else:
# s_len = 1
print(result)
``` | instruction | 0 | 92,539 | 23 | 185,078 |
No | output | 1 | 92,539 | 23 | 185,079 |
Provide a correct Python 3 solution for this coding contest problem.
There are a number of rectangles on the x-y plane. The four sides of the rectangles are parallel to either the x-axis or the y-axis, and all of the rectangles reside within a range specified later. There are no other constraints on the coordinates of the rectangles.
The plane is partitioned into regions surrounded by the sides of one or more rectangles. In an example shown in Figure C.1, three rectangles overlap one another, and the plane is partitioned into eight regions.
Rectangles may overlap in more complex ways. For example, two rectangles may have overlapped sides, they may share their corner points, and/or they may be nested. Figure C.2 illustrates such cases.
Your job is to write a program that counts the number of the regions on the plane partitioned by the rectangles.
Input
The input consists of multiple datasets. Each dataset is formatted as follows.
n
l1 t1 r1 b1
l2 t2 r2 b2
:
ln tn rn bn
A dataset starts with n (1 β€ n β€ 50), the number of rectangles on the plane. Each of the following n lines describes a rectangle. The i-th line contains four integers, li, ti, ri, and bi, which are the coordinates of the i-th rectangle; (li, ti) gives the x-y coordinates of the top left corner, and (ri, bi) gives that of the bottom right corner of the rectangle (0 β€ li < ri β€ 106, 0 β€ bi < ti β€ 106, for 1 β€ i β€ n). The four integers are separated by a space.
The input is terminated by a single zero.
Output
For each dataset, output a line containing the number of regions on the plane partitioned by the sides of the rectangles.
<image>
Figure C.1. Three rectangles partition the plane into eight regions. This corresponds to the first dataset of the sample input. The x- and y-axes are shown for illustration purposes only, and therefore they do not partition the plane.
<image>
Figure C.2. Rectangles overlapping in more complex ways. This corresponds to the second dataset.
Example
Input
3
4 28 27 11
15 20 42 5
11 24 33 14
5
4 28 27 11
12 11 34 2
7 26 14 16
14 16 19 12
17 28 27 21
2
300000 1000000 600000 0
0 600000 1000000 300000
0
Output
8
6
6 | instruction | 0 | 92,558 | 23 | 185,116 |
"Correct Solution:
```
import math,string,itertools,fractions,heapq,collections,re,array,bisect,sys,random,time,copy,functools
sys.setrecursionlimit(10**7)
inf = 10**20
eps = 1.0 / 10**13
mod = 10**9+7
dd = [(-1,0),(0,1),(1,0),(0,-1)]
ddn = [(-1,0),(-1,1),(0,1),(1,1),(1,0),(1,-1),(0,-1),(-1,-1)]
def LI(): return [int(x) for x in sys.stdin.readline().split()]
def LI_(): return [int(x)-1 for x in sys.stdin.readline().split()]
def LF(): return [float(x) for x in sys.stdin.readline().split()]
def LS(): return sys.stdin.readline().split()
def I(): return int(sys.stdin.readline())
def F(): return float(sys.stdin.readline())
def S(): return input()
def pf(s): return print(s, flush=True)
# δΊζ¬‘ε
η΄―η©ε
class Ruiwa():
def __init__(self, a):
self.H = h = len(a)
self.W = w = len(a[0])
self.R = r = a
for i in range(h):
for j in range(1,w):
r[i][j] += r[i][j-1]
for i in range(1,h):
for j in range(w):
r[i][j] += r[i-1][j]
def search(self, x1, y1, x2, y2):
if x1 > x2 or y1 > y2:
return 0
r = self.R
rr = r[y2][x2]
if x1 > 0 and y1 > 0:
return rr - r[y1-1][x2] - r[y2][x1-1] + r[y1-1][x1-1]
if x1 > 0:
rr -= r[y2][x1-1]
if y1 > 0:
rr -= r[y1-1][x2]
return rr
def main():
rr = []
def f(n):
a = [LI() for _ in range(n)]
xs = set()
ys = set()
for l,t,r,b in a:
xs.add(l)
xs.add(r)
ys.add(t)
ys.add(b)
xd = {}
for x,i in zip(sorted(xs), range(len(xs))):
xd[x] = i
yd = {}
for y,i in zip(sorted(ys), range(len(ys))):
yd[y] = i
z = []
for l,t,r,b in a:
z.append([xd[l],yd[t],xd[r],yd[b]])
xx = len(xs) + 3
yy = len(ys) + 3
aa = [[0]*xx for _ in range(yy)]
ii = [2**i for i in range(n)]
for i in range(n):
l,t,r,b = map(lambda x: x+1, z[i])
aa[b][l] += ii[i]
aa[t][l] -= ii[i]
aa[b][r] -= ii[i]
aa[t][r] += ii[i]
rui = Ruiwa(aa)
t = rui.R
def _f(i,j,k):
if i < 0 or i >= yy or j < 0 or j >= xx:
return
if t[i][j] != k:
return
t[i][j] = -1
for di,dj in dd:
_f(i+di,j+dj,k)
r = 0
for i in range(yy):
for j in range(xx):
if t[i][j] >= 0:
_f(i,j,t[i][j])
r += 1
return r
while True:
n = I()
if n == 0:
break
rr.append(f(n))
return '\n'.join(map(str,rr))
print(main())
``` | output | 1 | 92,558 | 23 | 185,117 |
Provide a correct Python 3 solution for this coding contest problem.
There are a number of rectangles on the x-y plane. The four sides of the rectangles are parallel to either the x-axis or the y-axis, and all of the rectangles reside within a range specified later. There are no other constraints on the coordinates of the rectangles.
The plane is partitioned into regions surrounded by the sides of one or more rectangles. In an example shown in Figure C.1, three rectangles overlap one another, and the plane is partitioned into eight regions.
Rectangles may overlap in more complex ways. For example, two rectangles may have overlapped sides, they may share their corner points, and/or they may be nested. Figure C.2 illustrates such cases.
Your job is to write a program that counts the number of the regions on the plane partitioned by the rectangles.
Input
The input consists of multiple datasets. Each dataset is formatted as follows.
n
l1 t1 r1 b1
l2 t2 r2 b2
:
ln tn rn bn
A dataset starts with n (1 β€ n β€ 50), the number of rectangles on the plane. Each of the following n lines describes a rectangle. The i-th line contains four integers, li, ti, ri, and bi, which are the coordinates of the i-th rectangle; (li, ti) gives the x-y coordinates of the top left corner, and (ri, bi) gives that of the bottom right corner of the rectangle (0 β€ li < ri β€ 106, 0 β€ bi < ti β€ 106, for 1 β€ i β€ n). The four integers are separated by a space.
The input is terminated by a single zero.
Output
For each dataset, output a line containing the number of regions on the plane partitioned by the sides of the rectangles.
<image>
Figure C.1. Three rectangles partition the plane into eight regions. This corresponds to the first dataset of the sample input. The x- and y-axes are shown for illustration purposes only, and therefore they do not partition the plane.
<image>
Figure C.2. Rectangles overlapping in more complex ways. This corresponds to the second dataset.
Example
Input
3
4 28 27 11
15 20 42 5
11 24 33 14
5
4 28 27 11
12 11 34 2
7 26 14 16
14 16 19 12
17 28 27 21
2
300000 1000000 600000 0
0 600000 1000000 300000
0
Output
8
6
6 | instruction | 0 | 92,559 | 23 | 185,118 |
"Correct Solution:
```
# coding: utf-8
import sys
sys.setrecursionlimit(1000000)
def check(i,j):
global n
global m
if m[i][j]==0:
m[i][j]=-1
if i+1<n*4+2:
check(i+1,j)
if i-1>=0:
check(i-1,j)
if j+1<n*4+2:
check(i,j+1)
if j-1>=0:
check(i,j-1)
while True:
n=int(input())
if n==0:
break
points=[]
plane=[[-1,-1,-1,-1] for i in range(n)]
dic={}
for i in range(n):
a,b,x,y=map(int,input().split())
dic[(a,b,i)]=0
dic[(x,y,i)]=1
points.append((a,b,i))
points.append((x,y,i))
points=sorted(points)
p=0
for i in range(len(points)):
if dic[points[i]]==0:
plane[points[i][2]][0]=p
else:
plane[points[i][2]][2]=p
if i+1<len(points) and points[i][0]==points[i+1][0]:
pass
else:
p+=1
points=sorted(points,key=lambda q:q[1])
p=0
for i in range(len(points)):
if dic[points[i]]==0:
plane[points[i][2]][1]=p
else:
plane[points[i][2]][3]=p
if i+1<len(points) and points[i][1]==points[i+1][1]:
pass
else:
p+=1
m=[[0 for i in range(n*4+2)]for i in range(n*4+2)]
for p in plane:
for j in range((p[1]-p[3])*2+1):
m[p[0]*2+1][p[3]*2+j+1]=1
m[p[2]*2+1][p[3]*2+j+1]=1
for j in range((p[2]-p[0])*2+1):
m[p[0]*2+j+1][p[3]*2+1]=1
m[p[0]*2+j+1][p[1]*2+1]=1
ans=0
for i in range(n*4+2):
for j in range(n*4+2):
if m[i][j]==0:
ans+=1
check(i,j)
print(ans)
``` | output | 1 | 92,559 | 23 | 185,119 |
Provide tags and a correct Python 3 solution for this coding contest problem.
Emuskald needs a fence around his farm, but he is too lazy to build it himself. So he purchased a fence-building robot.
He wants the fence to be a regular polygon. The robot builds the fence along a single path, but it can only make fence corners at a single angle a.
Will the robot be able to build the fence Emuskald wants? In other words, is there a regular polygon which angles are equal to a?
Input
The first line of input contains an integer t (0 < t < 180) β the number of tests. Each of the following t lines contains a single integer a (0 < a < 180) β the angle the robot can make corners at measured in degrees.
Output
For each test, output on a single line "YES" (without quotes), if the robot can build a fence Emuskald wants, and "NO" (without quotes), if it is impossible.
Examples
Input
3
30
60
90
Output
NO
YES
YES
Note
In the first test case, it is impossible to build the fence, since there is no regular polygon with angle <image>.
In the second test case, the fence is a regular triangle, and in the last test case β a square. | instruction | 0 | 92,959 | 23 | 185,918 |
Tags: geometry, implementation, math
Correct Solution:
```
# Fancy Fence
cases = int(input())
x = 0
while x < cases:
interiorAngle = int(input())
ExteriorAngle = 180 - interiorAngle
numOfEdgesFloat = 360 / ExteriorAngle
numOfEdgesInt = 360 // ExteriorAngle
if(numOfEdgesFloat == numOfEdgesInt):
print("YES")
else:
print("NO")
x += 1
``` | output | 1 | 92,959 | 23 | 185,919 |
Provide tags and a correct Python 3 solution for this coding contest problem.
Emuskald needs a fence around his farm, but he is too lazy to build it himself. So he purchased a fence-building robot.
He wants the fence to be a regular polygon. The robot builds the fence along a single path, but it can only make fence corners at a single angle a.
Will the robot be able to build the fence Emuskald wants? In other words, is there a regular polygon which angles are equal to a?
Input
The first line of input contains an integer t (0 < t < 180) β the number of tests. Each of the following t lines contains a single integer a (0 < a < 180) β the angle the robot can make corners at measured in degrees.
Output
For each test, output on a single line "YES" (without quotes), if the robot can build a fence Emuskald wants, and "NO" (without quotes), if it is impossible.
Examples
Input
3
30
60
90
Output
NO
YES
YES
Note
In the first test case, it is impossible to build the fence, since there is no regular polygon with angle <image>.
In the second test case, the fence is a regular triangle, and in the last test case β a square. | instruction | 0 | 92,960 | 23 | 185,920 |
Tags: geometry, implementation, math
Correct Solution:
```
options = []
for n in range(3,361):
if 180*(n-2) % n == 0:
options.append(180*(n-2) // n)
cases = int(input())
for _ in range(cases):
if int(input()) in options:
print('YES')
else:
print('NO')
``` | output | 1 | 92,960 | 23 | 185,921 |
Provide tags and a correct Python 3 solution for this coding contest problem.
Emuskald needs a fence around his farm, but he is too lazy to build it himself. So he purchased a fence-building robot.
He wants the fence to be a regular polygon. The robot builds the fence along a single path, but it can only make fence corners at a single angle a.
Will the robot be able to build the fence Emuskald wants? In other words, is there a regular polygon which angles are equal to a?
Input
The first line of input contains an integer t (0 < t < 180) β the number of tests. Each of the following t lines contains a single integer a (0 < a < 180) β the angle the robot can make corners at measured in degrees.
Output
For each test, output on a single line "YES" (without quotes), if the robot can build a fence Emuskald wants, and "NO" (without quotes), if it is impossible.
Examples
Input
3
30
60
90
Output
NO
YES
YES
Note
In the first test case, it is impossible to build the fence, since there is no regular polygon with angle <image>.
In the second test case, the fence is a regular triangle, and in the last test case β a square. | instruction | 0 | 92,961 | 23 | 185,922 |
Tags: geometry, implementation, math
Correct Solution:
```
for i in range(int(input())):
a = int(input())
if 360%(180-a)==0:
print('YES')
else:
print('NO')
``` | output | 1 | 92,961 | 23 | 185,923 |
Provide tags and a correct Python 3 solution for this coding contest problem.
Emuskald needs a fence around his farm, but he is too lazy to build it himself. So he purchased a fence-building robot.
He wants the fence to be a regular polygon. The robot builds the fence along a single path, but it can only make fence corners at a single angle a.
Will the robot be able to build the fence Emuskald wants? In other words, is there a regular polygon which angles are equal to a?
Input
The first line of input contains an integer t (0 < t < 180) β the number of tests. Each of the following t lines contains a single integer a (0 < a < 180) β the angle the robot can make corners at measured in degrees.
Output
For each test, output on a single line "YES" (without quotes), if the robot can build a fence Emuskald wants, and "NO" (without quotes), if it is impossible.
Examples
Input
3
30
60
90
Output
NO
YES
YES
Note
In the first test case, it is impossible to build the fence, since there is no regular polygon with angle <image>.
In the second test case, the fence is a regular triangle, and in the last test case β a square. | instruction | 0 | 92,962 | 23 | 185,924 |
Tags: geometry, implementation, math
Correct Solution:
```
from math import gcd
for i in range(int(input())):
x = int(input())
gcf = gcd(x,180)
a,b = x//gcf,180//gcf
if b-a == 2 or b*2-a*2 == 2:#Odd and Even cases
print('YES')
else:
print('NO')
``` | output | 1 | 92,962 | 23 | 185,925 |
Provide tags and a correct Python 3 solution for this coding contest problem.
Emuskald needs a fence around his farm, but he is too lazy to build it himself. So he purchased a fence-building robot.
He wants the fence to be a regular polygon. The robot builds the fence along a single path, but it can only make fence corners at a single angle a.
Will the robot be able to build the fence Emuskald wants? In other words, is there a regular polygon which angles are equal to a?
Input
The first line of input contains an integer t (0 < t < 180) β the number of tests. Each of the following t lines contains a single integer a (0 < a < 180) β the angle the robot can make corners at measured in degrees.
Output
For each test, output on a single line "YES" (without quotes), if the robot can build a fence Emuskald wants, and "NO" (without quotes), if it is impossible.
Examples
Input
3
30
60
90
Output
NO
YES
YES
Note
In the first test case, it is impossible to build the fence, since there is no regular polygon with angle <image>.
In the second test case, the fence is a regular triangle, and in the last test case β a square. | instruction | 0 | 92,963 | 23 | 185,926 |
Tags: geometry, implementation, math
Correct Solution:
```
t = int(input())
for i in range(t):
angle = int(input())
if(360%(180 - angle) == 0):
print("YES")
else:
print("NO")
``` | output | 1 | 92,963 | 23 | 185,927 |
Provide tags and a correct Python 3 solution for this coding contest problem.
Emuskald needs a fence around his farm, but he is too lazy to build it himself. So he purchased a fence-building robot.
He wants the fence to be a regular polygon. The robot builds the fence along a single path, but it can only make fence corners at a single angle a.
Will the robot be able to build the fence Emuskald wants? In other words, is there a regular polygon which angles are equal to a?
Input
The first line of input contains an integer t (0 < t < 180) β the number of tests. Each of the following t lines contains a single integer a (0 < a < 180) β the angle the robot can make corners at measured in degrees.
Output
For each test, output on a single line "YES" (without quotes), if the robot can build a fence Emuskald wants, and "NO" (without quotes), if it is impossible.
Examples
Input
3
30
60
90
Output
NO
YES
YES
Note
In the first test case, it is impossible to build the fence, since there is no regular polygon with angle <image>.
In the second test case, the fence is a regular triangle, and in the last test case β a square. | instruction | 0 | 92,964 | 23 | 185,928 |
Tags: geometry, implementation, math
Correct Solution:
```
# Author : raj1307 - Raj Singh
# Date : 02.01.2020
from __future__ import division, print_function
import os,sys
from io import BytesIO, IOBase
if sys.version_info[0] < 3:
from __builtin__ import xrange as range
from future_builtins import ascii, filter, hex, map, oct, zip
def ii(): return int(input())
def si(): return input()
def mi(): return map(int,input().strip().split(" "))
def msi(): return map(str,input().strip().split(" "))
def li(): return list(mi())
def dmain():
sys.setrecursionlimit(100000000)
threading.stack_size(40960000)
thread = threading.Thread(target=main)
thread.start()
#from collections import deque, Counter, OrderedDict,defaultdict
#from heapq import nsmallest, nlargest, heapify,heappop ,heappush, heapreplace
#from math import ceil,floor,log,sqrt,factorial
#from bisect import bisect,bisect_left,bisect_right,insort,insort_left,insort_right
#from decimal import *,threading
#from itertools import permutations
abc='abcdefghijklmnopqrstuvwxyz'
abd={'a': 0, 'b': 1, 'c': 2, 'd': 3, 'e': 4, 'f': 5, 'g': 6, 'h': 7, 'i': 8, 'j': 9, 'k': 10, 'l': 11, 'm': 12, 'n': 13, 'o': 14, 'p': 15, 'q': 16, 'r': 17, 's': 18, 't': 19, 'u': 20, 'v': 21, 'w': 22, 'x': 23, 'y': 24, 'z': 25}
mod=1000000007
#mod=998244353
inf = float("inf")
vow=['a','e','i','o','u']
dx,dy=[-1,1,0,0],[0,0,1,-1]
def getKey(item): return item[1]
def sort2(l):return sorted(l, key=getKey)
def d2(n,m,num):return [[num for x in range(m)] for y in range(n)]
def isPowerOfTwo (x): return (x and (not(x & (x - 1))) )
def decimalToBinary(n): return bin(n).replace("0b","")
def ntl(n):return [int(i) for i in str(n)]
def powerMod(x,y,p):
res = 1
x %= p
while y > 0:
if y&1:
res = (res*x)%p
y = y>>1
x = (x*x)%p
return res
def gcd(x, y):
while y:
x, y = y, x % y
return x
def isPrime(n) : # Check Prime Number or not
if (n <= 1) : return False
if (n <= 3) : return True
if (n % 2 == 0 or n % 3 == 0) : return False
i = 5
while(i * i <= n) :
if (n % i == 0 or n % (i + 2) == 0) :
return False
i = i + 6
return True
def read():
sys.stdin = open('input.txt', 'r')
sys.stdout = open('output.txt', 'w')
def main():
for _ in range(ii()):
n=ii()
if 360%(180-n)==0:
print('YES')
else:
print('NO')
# region fastio
BUFSIZE = 8192
class FastIO(IOBase):
newlines = 0
def __init__(self, file):
self._fd = file.fileno()
self.buffer = BytesIO()
self.writable = "x" in file.mode or "r" not in file.mode
self.write = self.buffer.write if self.writable else None
def read(self):
while True:
b = os.read(self._fd, max(os.fstat(self._fd).st_size, BUFSIZE))
if not b:
break
ptr = self.buffer.tell()
self.buffer.seek(0, 2), self.buffer.write(b), self.buffer.seek(ptr)
self.newlines = 0
return self.buffer.read()
def readline(self):
while self.newlines == 0:
b = os.read(self._fd, max(os.fstat(self._fd).st_size, BUFSIZE))
self.newlines = b.count(b"\n") + (not b)
ptr = self.buffer.tell()
self.buffer.seek(0, 2), self.buffer.write(b), self.buffer.seek(ptr)
self.newlines -= 1
return self.buffer.readline()
def flush(self):
if self.writable:
os.write(self._fd, self.buffer.getvalue())
self.buffer.truncate(0), self.buffer.seek(0)
class IOWrapper(IOBase):
def __init__(self, file):
self.buffer = FastIO(file)
self.flush = self.buffer.flush
self.writable = self.buffer.writable
self.write = lambda s: self.buffer.write(s.encode("ascii"))
self.read = lambda: self.buffer.read().decode("ascii")
self.readline = lambda: self.buffer.readline().decode("ascii")
def print(*args, **kwargs):
"""Prints the values to a stream, or to sys.stdout by default."""
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()
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)
input = lambda: sys.stdin.readline().rstrip("\r\n")
# endregion
if __name__ == "__main__":
#read()
main()
#dmain()
# Comment Read()
``` | output | 1 | 92,964 | 23 | 185,929 |
Provide tags and a correct Python 3 solution for this coding contest problem.
Emuskald needs a fence around his farm, but he is too lazy to build it himself. So he purchased a fence-building robot.
He wants the fence to be a regular polygon. The robot builds the fence along a single path, but it can only make fence corners at a single angle a.
Will the robot be able to build the fence Emuskald wants? In other words, is there a regular polygon which angles are equal to a?
Input
The first line of input contains an integer t (0 < t < 180) β the number of tests. Each of the following t lines contains a single integer a (0 < a < 180) β the angle the robot can make corners at measured in degrees.
Output
For each test, output on a single line "YES" (without quotes), if the robot can build a fence Emuskald wants, and "NO" (without quotes), if it is impossible.
Examples
Input
3
30
60
90
Output
NO
YES
YES
Note
In the first test case, it is impossible to build the fence, since there is no regular polygon with angle <image>.
In the second test case, the fence is a regular triangle, and in the last test case β a square. | instruction | 0 | 92,965 | 23 | 185,930 |
Tags: geometry, implementation, math
Correct Solution:
```
import sys
input = sys.stdin.readline
ins = lambda: input().rstrip()
ini = lambda: int(input().rstrip())
inm = lambda: map(int, input().split())
inl = lambda: list(map(int, input().split()))
out = lambda x: print('\n'.join(map(str, x)))
ans = []
t = ini()
for _ in range(t):
n = ini()
ans.append("YES" if (360 % (180 - n)) == 0 else "NO")
out(ans)
``` | output | 1 | 92,965 | 23 | 185,931 |
Provide tags and a correct Python 3 solution for this coding contest problem.
Emuskald needs a fence around his farm, but he is too lazy to build it himself. So he purchased a fence-building robot.
He wants the fence to be a regular polygon. The robot builds the fence along a single path, but it can only make fence corners at a single angle a.
Will the robot be able to build the fence Emuskald wants? In other words, is there a regular polygon which angles are equal to a?
Input
The first line of input contains an integer t (0 < t < 180) β the number of tests. Each of the following t lines contains a single integer a (0 < a < 180) β the angle the robot can make corners at measured in degrees.
Output
For each test, output on a single line "YES" (without quotes), if the robot can build a fence Emuskald wants, and "NO" (without quotes), if it is impossible.
Examples
Input
3
30
60
90
Output
NO
YES
YES
Note
In the first test case, it is impossible to build the fence, since there is no regular polygon with angle <image>.
In the second test case, the fence is a regular triangle, and in the last test case β a square. | instruction | 0 | 92,966 | 23 | 185,932 |
Tags: geometry, implementation, math
Correct Solution:
```
t = int(input())
for i in range(t):
n = int(input())
if 360 % (180-n) == 0:
print('YES')
else:
print('NO')
``` | output | 1 | 92,966 | 23 | 185,933 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
Emuskald needs a fence around his farm, but he is too lazy to build it himself. So he purchased a fence-building robot.
He wants the fence to be a regular polygon. The robot builds the fence along a single path, but it can only make fence corners at a single angle a.
Will the robot be able to build the fence Emuskald wants? In other words, is there a regular polygon which angles are equal to a?
Input
The first line of input contains an integer t (0 < t < 180) β the number of tests. Each of the following t lines contains a single integer a (0 < a < 180) β the angle the robot can make corners at measured in degrees.
Output
For each test, output on a single line "YES" (without quotes), if the robot can build a fence Emuskald wants, and "NO" (without quotes), if it is impossible.
Examples
Input
3
30
60
90
Output
NO
YES
YES
Note
In the first test case, it is impossible to build the fence, since there is no regular polygon with angle <image>.
In the second test case, the fence is a regular triangle, and in the last test case β a square.
Submitted Solution:
```
n_list = [3, 4, 5, 6, 8, 9, 10, 12, 15, 18, 20, 24, 30, 36, 40, 45, 60, 72, 90, 120, 180, 360]
tests = int(input())
def is_regular(angle):
for n in n_list:
if angle == 180 - (360/n):
return True
return False
for i in range(tests):
if is_regular(int(input())):
print("YES")
else:
print("NO")
``` | instruction | 0 | 92,967 | 23 | 185,934 |
Yes | output | 1 | 92,967 | 23 | 185,935 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
Emuskald needs a fence around his farm, but he is too lazy to build it himself. So he purchased a fence-building robot.
He wants the fence to be a regular polygon. The robot builds the fence along a single path, but it can only make fence corners at a single angle a.
Will the robot be able to build the fence Emuskald wants? In other words, is there a regular polygon which angles are equal to a?
Input
The first line of input contains an integer t (0 < t < 180) β the number of tests. Each of the following t lines contains a single integer a (0 < a < 180) β the angle the robot can make corners at measured in degrees.
Output
For each test, output on a single line "YES" (without quotes), if the robot can build a fence Emuskald wants, and "NO" (without quotes), if it is impossible.
Examples
Input
3
30
60
90
Output
NO
YES
YES
Note
In the first test case, it is impossible to build the fence, since there is no regular polygon with angle <image>.
In the second test case, the fence is a regular triangle, and in the last test case β a square.
Submitted Solution:
```
N=int(input())
for i in range(N):
a=int(input())
n=360.0/(180-a)
if n%1==0:
print('YES')
else:
print('NO')
``` | instruction | 0 | 92,968 | 23 | 185,936 |
Yes | output | 1 | 92,968 | 23 | 185,937 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
Emuskald needs a fence around his farm, but he is too lazy to build it himself. So he purchased a fence-building robot.
He wants the fence to be a regular polygon. The robot builds the fence along a single path, but it can only make fence corners at a single angle a.
Will the robot be able to build the fence Emuskald wants? In other words, is there a regular polygon which angles are equal to a?
Input
The first line of input contains an integer t (0 < t < 180) β the number of tests. Each of the following t lines contains a single integer a (0 < a < 180) β the angle the robot can make corners at measured in degrees.
Output
For each test, output on a single line "YES" (without quotes), if the robot can build a fence Emuskald wants, and "NO" (without quotes), if it is impossible.
Examples
Input
3
30
60
90
Output
NO
YES
YES
Note
In the first test case, it is impossible to build the fence, since there is no regular polygon with angle <image>.
In the second test case, the fence is a regular triangle, and in the last test case β a square.
Submitted Solution:
```
t=int(input())
for i in range(t):
a=int(input())
f=360/(180-a)
if f>=3 and f%1==0:
print("YES")
else:
print("NO")
``` | instruction | 0 | 92,969 | 23 | 185,938 |
Yes | output | 1 | 92,969 | 23 | 185,939 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
Emuskald needs a fence around his farm, but he is too lazy to build it himself. So he purchased a fence-building robot.
He wants the fence to be a regular polygon. The robot builds the fence along a single path, but it can only make fence corners at a single angle a.
Will the robot be able to build the fence Emuskald wants? In other words, is there a regular polygon which angles are equal to a?
Input
The first line of input contains an integer t (0 < t < 180) β the number of tests. Each of the following t lines contains a single integer a (0 < a < 180) β the angle the robot can make corners at measured in degrees.
Output
For each test, output on a single line "YES" (without quotes), if the robot can build a fence Emuskald wants, and "NO" (without quotes), if it is impossible.
Examples
Input
3
30
60
90
Output
NO
YES
YES
Note
In the first test case, it is impossible to build the fence, since there is no regular polygon with angle <image>.
In the second test case, the fence is a regular triangle, and in the last test case β a square.
Submitted Solution:
```
def ok(integer):
if 360%(180-integer)==0:
return "YES"
else:
return "NO"
stor=[]
sa=input()
for x in range(int(sa)):
stor.append(ok(int(input())))
for element in stor:
print(element)
``` | instruction | 0 | 92,970 | 23 | 185,940 |
Yes | output | 1 | 92,970 | 23 | 185,941 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
Emuskald needs a fence around his farm, but he is too lazy to build it himself. So he purchased a fence-building robot.
He wants the fence to be a regular polygon. The robot builds the fence along a single path, but it can only make fence corners at a single angle a.
Will the robot be able to build the fence Emuskald wants? In other words, is there a regular polygon which angles are equal to a?
Input
The first line of input contains an integer t (0 < t < 180) β the number of tests. Each of the following t lines contains a single integer a (0 < a < 180) β the angle the robot can make corners at measured in degrees.
Output
For each test, output on a single line "YES" (without quotes), if the robot can build a fence Emuskald wants, and "NO" (without quotes), if it is impossible.
Examples
Input
3
30
60
90
Output
NO
YES
YES
Note
In the first test case, it is impossible to build the fence, since there is no regular polygon with angle <image>.
In the second test case, the fence is a regular triangle, and in the last test case β a square.
Submitted Solution:
```
t = int(input())
g = ''
for i in range(t):
a = int(input())
if (1080 % a == 0) and (a > 30):
g += 'YES '
else:
g += 'NO '
print('\n'.join(g.split()))
``` | instruction | 0 | 92,971 | 23 | 185,942 |
No | output | 1 | 92,971 | 23 | 185,943 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
Emuskald needs a fence around his farm, but he is too lazy to build it himself. So he purchased a fence-building robot.
He wants the fence to be a regular polygon. The robot builds the fence along a single path, but it can only make fence corners at a single angle a.
Will the robot be able to build the fence Emuskald wants? In other words, is there a regular polygon which angles are equal to a?
Input
The first line of input contains an integer t (0 < t < 180) β the number of tests. Each of the following t lines contains a single integer a (0 < a < 180) β the angle the robot can make corners at measured in degrees.
Output
For each test, output on a single line "YES" (without quotes), if the robot can build a fence Emuskald wants, and "NO" (without quotes), if it is impossible.
Examples
Input
3
30
60
90
Output
NO
YES
YES
Note
In the first test case, it is impossible to build the fence, since there is no regular polygon with angle <image>.
In the second test case, the fence is a regular triangle, and in the last test case β a square.
Submitted Solution:
```
for _ in range(int(input())):
a = int(input())
n = 3
while True:
if ((n-2)*180)//n >= a:
break
n += 1
if ((n-2)*180)%n == 0:
if ((n-2)*180)//n == a:
print(((n-2)*180)//n)
print('YES')
else:
print('NO')
else:
print('NO')
``` | instruction | 0 | 92,972 | 23 | 185,944 |
No | output | 1 | 92,972 | 23 | 185,945 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
Emuskald needs a fence around his farm, but he is too lazy to build it himself. So he purchased a fence-building robot.
He wants the fence to be a regular polygon. The robot builds the fence along a single path, but it can only make fence corners at a single angle a.
Will the robot be able to build the fence Emuskald wants? In other words, is there a regular polygon which angles are equal to a?
Input
The first line of input contains an integer t (0 < t < 180) β the number of tests. Each of the following t lines contains a single integer a (0 < a < 180) β the angle the robot can make corners at measured in degrees.
Output
For each test, output on a single line "YES" (without quotes), if the robot can build a fence Emuskald wants, and "NO" (without quotes), if it is impossible.
Examples
Input
3
30
60
90
Output
NO
YES
YES
Note
In the first test case, it is impossible to build the fence, since there is no regular polygon with angle <image>.
In the second test case, the fence is a regular triangle, and in the last test case β a square.
Submitted Solution:
```
# A. ΠΠ°Π²ΠΈΠ΄Π½ΡΠΉ Π·Π°Π±ΠΎΡ
n = int(input())
for i in range(n):
a = int(input())
if 3 <= 360 / (180 - a) < 360:
print("YES")
else:
print("NO")
``` | instruction | 0 | 92,973 | 23 | 185,946 |
No | output | 1 | 92,973 | 23 | 185,947 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
Emuskald needs a fence around his farm, but he is too lazy to build it himself. So he purchased a fence-building robot.
He wants the fence to be a regular polygon. The robot builds the fence along a single path, but it can only make fence corners at a single angle a.
Will the robot be able to build the fence Emuskald wants? In other words, is there a regular polygon which angles are equal to a?
Input
The first line of input contains an integer t (0 < t < 180) β the number of tests. Each of the following t lines contains a single integer a (0 < a < 180) β the angle the robot can make corners at measured in degrees.
Output
For each test, output on a single line "YES" (without quotes), if the robot can build a fence Emuskald wants, and "NO" (without quotes), if it is impossible.
Examples
Input
3
30
60
90
Output
NO
YES
YES
Note
In the first test case, it is impossible to build the fence, since there is no regular polygon with angle <image>.
In the second test case, the fence is a regular triangle, and in the last test case β a square.
Submitted Solution:
```
n = int(input())
for i in range(n):
a = int(input())
e = 360/(180-a)
absolute = abs(e)
rounded = round(e)
if(e>=3):
if(absolute - rounded ==0):
print("YES")
# print(e)
else:
print("NO")
``` | instruction | 0 | 92,974 | 23 | 185,948 |
No | output | 1 | 92,974 | 23 | 185,949 |
Provide a correct Python 3 solution for this coding contest problem.
<image>
Arrange integers (0 or more and 99 or less) in a rhombus as illustrated in Fig. 1. Create a program that reads the data representing the rhombus and outputs the maximum value of the sum of the integers that pass when starting from the top and proceeding to the bottom according to the following rules.
* At each step, you can proceed to the lower left diagonal or the lower right diagonal.
For example, in the example of Fig. 1, as shown in Fig. 2, when 7,3,8,7,5,7,8,3,7 is selected and passed, the sum is the maximum 55 (7 + 3 + 8). + 7 + 5 + 7 + 8 + 3 + 7 = 55).
Input
As shown in the input example, a comma-separated sequence of integers is given to the diamond. Each line does not contain whitespace. The input example corresponds to Fig. 1. There are less than 100 rows of data.
Output
Outputs the maximum value of the sum of integers that pass according to the rules on one line.
Example
Input
7
3,8
8,1,0
2,7,4,4
4,5,2,6,5
2,7,4,4
8,1,0
3,8
7
Output
55 | instruction | 0 | 93,407 | 23 | 186,814 |
"Correct Solution:
```
INF=1e8
path=[]
dp=[]
while(True):
try:
temp=list(map(int,input().split(',')))
path.append(temp)
dp.append([INF for i in range(len(temp))])
except:
break
dp[0][0]=path[0][0]
for i in range(1,len(dp)):
for j in range(len(dp[i])):
if len(dp[i])>len(dp[i-1]):
start=0 if j-1<0 else j-1
dp[i][j]=max(dp[i-1][start:j+1])+path[i][j]
else:
dp[i][j]=max(dp[i-1][j:j+2])+path[i][j]
print(dp[-1][-1])
``` | output | 1 | 93,407 | 23 | 186,815 |
Provide a correct Python 3 solution for this coding contest problem.
<image>
Arrange integers (0 or more and 99 or less) in a rhombus as illustrated in Fig. 1. Create a program that reads the data representing the rhombus and outputs the maximum value of the sum of the integers that pass when starting from the top and proceeding to the bottom according to the following rules.
* At each step, you can proceed to the lower left diagonal or the lower right diagonal.
For example, in the example of Fig. 1, as shown in Fig. 2, when 7,3,8,7,5,7,8,3,7 is selected and passed, the sum is the maximum 55 (7 + 3 + 8). + 7 + 5 + 7 + 8 + 3 + 7 = 55).
Input
As shown in the input example, a comma-separated sequence of integers is given to the diamond. Each line does not contain whitespace. The input example corresponds to Fig. 1. There are less than 100 rows of data.
Output
Outputs the maximum value of the sum of integers that pass according to the rules on one line.
Example
Input
7
3,8
8,1,0
2,7,4,4
4,5,2,6,5
2,7,4,4
8,1,0
3,8
7
Output
55 | instruction | 0 | 93,408 | 23 | 186,816 |
"Correct Solution:
```
import sys
s=[list(map(int,e.split(',')))for e in sys.stdin]
for i in range(1,len(s)):
for j in range(len(s[i])):
b=len(s[i])>len(s[i-1])
s[i][j]+=max(s[i-1][(j-b)*(j>0):j+2-b])
print(*s[-1])
``` | output | 1 | 93,408 | 23 | 186,817 |
Provide a correct Python 3 solution for this coding contest problem.
<image>
Arrange integers (0 or more and 99 or less) in a rhombus as illustrated in Fig. 1. Create a program that reads the data representing the rhombus and outputs the maximum value of the sum of the integers that pass when starting from the top and proceeding to the bottom according to the following rules.
* At each step, you can proceed to the lower left diagonal or the lower right diagonal.
For example, in the example of Fig. 1, as shown in Fig. 2, when 7,3,8,7,5,7,8,3,7 is selected and passed, the sum is the maximum 55 (7 + 3 + 8). + 7 + 5 + 7 + 8 + 3 + 7 = 55).
Input
As shown in the input example, a comma-separated sequence of integers is given to the diamond. Each line does not contain whitespace. The input example corresponds to Fig. 1. There are less than 100 rows of data.
Output
Outputs the maximum value of the sum of integers that pass according to the rules on one line.
Example
Input
7
3,8
8,1,0
2,7,4,4
4,5,2,6,5
2,7,4,4
8,1,0
3,8
7
Output
55 | instruction | 0 | 93,409 | 23 | 186,818 |
"Correct Solution:
```
path=[]
while(True):
try:
temp=list(map(int,input().split(',')))
path.append(temp)
except:
break
path[0][0]
for i in range(1,len(path)):
for j in range(len(path[i])):
if len(path[i])>len(path[i-1]):
start=0 if j<1 else j-1
path[i][j]+=max(path[i-1][start:j+1])
else:
path[i][j]+=max(path[i-1][j:j+2])
print(path[-1][-1])
``` | output | 1 | 93,409 | 23 | 186,819 |
Provide a correct Python 3 solution for this coding contest problem.
<image>
Arrange integers (0 or more and 99 or less) in a rhombus as illustrated in Fig. 1. Create a program that reads the data representing the rhombus and outputs the maximum value of the sum of the integers that pass when starting from the top and proceeding to the bottom according to the following rules.
* At each step, you can proceed to the lower left diagonal or the lower right diagonal.
For example, in the example of Fig. 1, as shown in Fig. 2, when 7,3,8,7,5,7,8,3,7 is selected and passed, the sum is the maximum 55 (7 + 3 + 8). + 7 + 5 + 7 + 8 + 3 + 7 = 55).
Input
As shown in the input example, a comma-separated sequence of integers is given to the diamond. Each line does not contain whitespace. The input example corresponds to Fig. 1. There are less than 100 rows of data.
Output
Outputs the maximum value of the sum of integers that pass according to the rules on one line.
Example
Input
7
3,8
8,1,0
2,7,4,4
4,5,2,6,5
2,7,4,4
8,1,0
3,8
7
Output
55 | instruction | 0 | 93,410 | 23 | 186,820 |
"Correct Solution:
```
import sys
s=[list(map(int,e.split(',')))for e in sys.stdin]
for i in range(1,len(s)):
k=len(s[i])
for j in range(k):
t=j-(k>len(s[i-1]))
s[i][j]+=max(s[i-1][t*(j>0):t+2])
print(*s[-1])
``` | output | 1 | 93,410 | 23 | 186,821 |
Provide a correct Python 3 solution for this coding contest problem.
<image>
Arrange integers (0 or more and 99 or less) in a rhombus as illustrated in Fig. 1. Create a program that reads the data representing the rhombus and outputs the maximum value of the sum of the integers that pass when starting from the top and proceeding to the bottom according to the following rules.
* At each step, you can proceed to the lower left diagonal or the lower right diagonal.
For example, in the example of Fig. 1, as shown in Fig. 2, when 7,3,8,7,5,7,8,3,7 is selected and passed, the sum is the maximum 55 (7 + 3 + 8). + 7 + 5 + 7 + 8 + 3 + 7 = 55).
Input
As shown in the input example, a comma-separated sequence of integers is given to the diamond. Each line does not contain whitespace. The input example corresponds to Fig. 1. There are less than 100 rows of data.
Output
Outputs the maximum value of the sum of integers that pass according to the rules on one line.
Example
Input
7
3,8
8,1,0
2,7,4,4
4,5,2,6,5
2,7,4,4
8,1,0
3,8
7
Output
55 | instruction | 0 | 93,411 | 23 | 186,822 |
"Correct Solution:
```
diamond=[]
path=[]
while True:
try:
s=[int(i) for i in input().split(",")]
if(len(diamond)==0):
diamond.append(s)
path.append(s)
elif(len(diamond[-1])<len(s)):
diamond.append(s)
_path=[path[-1][0]+s[0]]
for i in range(len(s)-2):
_path.append(max(path[-1][i],path[-1][i+1])+s[i+1])
_path.append(path[-1][-1]+s[-1])
path.append(_path)
else:
diamond.append(s)
_path=[]
for i in range(len(s)):
_path.append(max(path[-1][i],path[-1][i+1])+s[i])
path.append(_path)
if len(s)==1:
print(path[-1][0])
diamond=[]
path=[]
except EOFError:
break
``` | output | 1 | 93,411 | 23 | 186,823 |
Provide a correct Python 3 solution for this coding contest problem.
<image>
Arrange integers (0 or more and 99 or less) in a rhombus as illustrated in Fig. 1. Create a program that reads the data representing the rhombus and outputs the maximum value of the sum of the integers that pass when starting from the top and proceeding to the bottom according to the following rules.
* At each step, you can proceed to the lower left diagonal or the lower right diagonal.
For example, in the example of Fig. 1, as shown in Fig. 2, when 7,3,8,7,5,7,8,3,7 is selected and passed, the sum is the maximum 55 (7 + 3 + 8). + 7 + 5 + 7 + 8 + 3 + 7 = 55).
Input
As shown in the input example, a comma-separated sequence of integers is given to the diamond. Each line does not contain whitespace. The input example corresponds to Fig. 1. There are less than 100 rows of data.
Output
Outputs the maximum value of the sum of integers that pass according to the rules on one line.
Example
Input
7
3,8
8,1,0
2,7,4,4
4,5,2,6,5
2,7,4,4
8,1,0
3,8
7
Output
55 | instruction | 0 | 93,412 | 23 | 186,824 |
"Correct Solution:
```
while 1:
try:
count = 0
rom = []
while count != 2:
N = list(map(int, input().split(",")))
if len(N) == 1:
count += 1
rom.append(N)
half = len(rom) // 2
for i in range(1, len(rom)):
for j in range(len(rom[i])):
if i <= half:
if j != 0 and j != len(rom[i]) - 1:
rom[i][j] = max(rom[i - 1][j], rom[i - 1][j - 1]) + rom[i][j]
elif j == 0:
rom[i][j] = rom[i - 1][j] + rom[i][j]
else:
rom[i][j] = rom[i - 1][j - 1] + rom[i][j]
else:
rom[i][j] = max(rom[i - 1][j], rom[i - 1][j + 1]) + rom[i][j]
print(rom[-1][0])
except:
break
``` | output | 1 | 93,412 | 23 | 186,825 |
Provide a correct Python 3 solution for this coding contest problem.
<image>
Arrange integers (0 or more and 99 or less) in a rhombus as illustrated in Fig. 1. Create a program that reads the data representing the rhombus and outputs the maximum value of the sum of the integers that pass when starting from the top and proceeding to the bottom according to the following rules.
* At each step, you can proceed to the lower left diagonal or the lower right diagonal.
For example, in the example of Fig. 1, as shown in Fig. 2, when 7,3,8,7,5,7,8,3,7 is selected and passed, the sum is the maximum 55 (7 + 3 + 8). + 7 + 5 + 7 + 8 + 3 + 7 = 55).
Input
As shown in the input example, a comma-separated sequence of integers is given to the diamond. Each line does not contain whitespace. The input example corresponds to Fig. 1. There are less than 100 rows of data.
Output
Outputs the maximum value of the sum of integers that pass according to the rules on one line.
Example
Input
7
3,8
8,1,0
2,7,4,4
4,5,2,6,5
2,7,4,4
8,1,0
3,8
7
Output
55 | instruction | 0 | 93,413 | 23 | 186,826 |
"Correct Solution:
```
import sys
path=[list(map(int,e.split(',')))for e in sys.stdin]
for i in range(1,len(path)):
for j in range(len(path[i])):
if len(path[i])>len(path[i-1]):
start=0 if j<1 else j-1
path[i][j]+=max(path[i-1][start:j+1])
else:
path[i][j]+=max(path[i-1][j:j+2])
print(path[-1][-1])
``` | output | 1 | 93,413 | 23 | 186,827 |
Provide a correct Python 3 solution for this coding contest problem.
<image>
Arrange integers (0 or more and 99 or less) in a rhombus as illustrated in Fig. 1. Create a program that reads the data representing the rhombus and outputs the maximum value of the sum of the integers that pass when starting from the top and proceeding to the bottom according to the following rules.
* At each step, you can proceed to the lower left diagonal or the lower right diagonal.
For example, in the example of Fig. 1, as shown in Fig. 2, when 7,3,8,7,5,7,8,3,7 is selected and passed, the sum is the maximum 55 (7 + 3 + 8). + 7 + 5 + 7 + 8 + 3 + 7 = 55).
Input
As shown in the input example, a comma-separated sequence of integers is given to the diamond. Each line does not contain whitespace. The input example corresponds to Fig. 1. There are less than 100 rows of data.
Output
Outputs the maximum value of the sum of integers that pass according to the rules on one line.
Example
Input
7
3,8
8,1,0
2,7,4,4
4,5,2,6,5
2,7,4,4
8,1,0
3,8
7
Output
55 | instruction | 0 | 93,414 | 23 | 186,828 |
"Correct Solution:
```
import sys
s=[list(map(int,e.split(',')))for e in sys.stdin]
for i in range(1,len(s)):
k=len(s[i]);b=k>len(s[i-1])
for j in range(k):
t=j-b;s[i][j]+=max(s[i-1][t*(j>0):t+2])
print(*s[-1])
``` | output | 1 | 93,414 | 23 | 186,829 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
<image>
Arrange integers (0 or more and 99 or less) in a rhombus as illustrated in Fig. 1. Create a program that reads the data representing the rhombus and outputs the maximum value of the sum of the integers that pass when starting from the top and proceeding to the bottom according to the following rules.
* At each step, you can proceed to the lower left diagonal or the lower right diagonal.
For example, in the example of Fig. 1, as shown in Fig. 2, when 7,3,8,7,5,7,8,3,7 is selected and passed, the sum is the maximum 55 (7 + 3 + 8). + 7 + 5 + 7 + 8 + 3 + 7 = 55).
Input
As shown in the input example, a comma-separated sequence of integers is given to the diamond. Each line does not contain whitespace. The input example corresponds to Fig. 1. There are less than 100 rows of data.
Output
Outputs the maximum value of the sum of integers that pass according to the rules on one line.
Example
Input
7
3,8
8,1,0
2,7,4,4
4,5,2,6,5
2,7,4,4
8,1,0
3,8
7
Output
55
Submitted Solution:
```
import sys
s=[list(map(int,e.split(',')))for e in sys.stdin]
for i in range(1,len(s)):
k=len(s[i]);b=k>len(s[i-1])
for j in range(k):s[i][j]+=max(s[i-1][(j-b)*(j>0):j-b+2])
print(*s[-1])
``` | instruction | 0 | 93,415 | 23 | 186,830 |
Yes | output | 1 | 93,415 | 23 | 186,831 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
<image>
Arrange integers (0 or more and 99 or less) in a rhombus as illustrated in Fig. 1. Create a program that reads the data representing the rhombus and outputs the maximum value of the sum of the integers that pass when starting from the top and proceeding to the bottom according to the following rules.
* At each step, you can proceed to the lower left diagonal or the lower right diagonal.
For example, in the example of Fig. 1, as shown in Fig. 2, when 7,3,8,7,5,7,8,3,7 is selected and passed, the sum is the maximum 55 (7 + 3 + 8). + 7 + 5 + 7 + 8 + 3 + 7 = 55).
Input
As shown in the input example, a comma-separated sequence of integers is given to the diamond. Each line does not contain whitespace. The input example corresponds to Fig. 1. There are less than 100 rows of data.
Output
Outputs the maximum value of the sum of integers that pass according to the rules on one line.
Example
Input
7
3,8
8,1,0
2,7,4,4
4,5,2,6,5
2,7,4,4
8,1,0
3,8
7
Output
55
Submitted Solution:
```
def get_input():
while True:
try:
yield ''.join(input())
except EOFError:
break
table = [[0 for i in range(100)] for j in range(100)]
L = list(get_input())
N = len(L) // 2 + 1
for l in range(N):
points = [int(i) for i in L[l].split(",")]
for i in range(len(points)):
table[len(points)-i-1][i] = points[i]
for l in range(N, 2*N-1):
#print(l)
points = [int(i) for i in L[l].split(",")]
for i in range(len(points)):
#print(len(points)-i-1+(l-N+1),i+(l-N+1))
table[len(points)-i-1+(l-N+1)][i+(l-N+1)] = points[i]
for c in range(1,2*N):
for i in range(c):
if c-i-2 < 0:
table[c-i-1][i] += table[c-i-1][i-1]
elif i-1 < 0:
table[c-i-1][i] += table[c-i-2][i]
else:
table[c-i-1][i] += max(table[c-i-2][i], table[c-i-1][i-1])
#for i in range(N):
# for j in range(N):
# print(table[i][j], end=" ")
# print("")
print(table[N-1][N-1])
``` | instruction | 0 | 93,416 | 23 | 186,832 |
Yes | output | 1 | 93,416 | 23 | 186,833 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
<image>
Arrange integers (0 or more and 99 or less) in a rhombus as illustrated in Fig. 1. Create a program that reads the data representing the rhombus and outputs the maximum value of the sum of the integers that pass when starting from the top and proceeding to the bottom according to the following rules.
* At each step, you can proceed to the lower left diagonal or the lower right diagonal.
For example, in the example of Fig. 1, as shown in Fig. 2, when 7,3,8,7,5,7,8,3,7 is selected and passed, the sum is the maximum 55 (7 + 3 + 8). + 7 + 5 + 7 + 8 + 3 + 7 = 55).
Input
As shown in the input example, a comma-separated sequence of integers is given to the diamond. Each line does not contain whitespace. The input example corresponds to Fig. 1. There are less than 100 rows of data.
Output
Outputs the maximum value of the sum of integers that pass according to the rules on one line.
Example
Input
7
3,8
8,1,0
2,7,4,4
4,5,2,6,5
2,7,4,4
8,1,0
3,8
7
Output
55
Submitted Solution:
```
ans = [int(input())]
while True:
try:
inp = list(map(int, input().split(",")))
l = len(inp)
if l > len(ans):
tmp = [-float("inf")] + ans + [-float("inf")]
else:
tmp = ans
ans = []
for i in range(l):
ans.append(max([tmp[i] + inp[i], tmp[i + 1] + inp[i]]))
except:
break
print(*ans)
``` | instruction | 0 | 93,417 | 23 | 186,834 |
Yes | output | 1 | 93,417 | 23 | 186,835 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
<image>
Arrange integers (0 or more and 99 or less) in a rhombus as illustrated in Fig. 1. Create a program that reads the data representing the rhombus and outputs the maximum value of the sum of the integers that pass when starting from the top and proceeding to the bottom according to the following rules.
* At each step, you can proceed to the lower left diagonal or the lower right diagonal.
For example, in the example of Fig. 1, as shown in Fig. 2, when 7,3,8,7,5,7,8,3,7 is selected and passed, the sum is the maximum 55 (7 + 3 + 8). + 7 + 5 + 7 + 8 + 3 + 7 = 55).
Input
As shown in the input example, a comma-separated sequence of integers is given to the diamond. Each line does not contain whitespace. The input example corresponds to Fig. 1. There are less than 100 rows of data.
Output
Outputs the maximum value of the sum of integers that pass according to the rules on one line.
Example
Input
7
3,8
8,1,0
2,7,4,4
4,5,2,6,5
2,7,4,4
8,1,0
3,8
7
Output
55
Submitted Solution:
```
ans = [int(input())]
import sys
for e in sys.stdin:
inp = list(map(int, e.split(",")))
l = len(inp)
if l > len(ans):
tmp = [-float("inf")] + ans + [-float("inf")]
else:
tmp = ans
ans = []
for i in range(l):
ans += [max([tmp[i] + inp[i], tmp[i + 1] + inp[i]])]
print(*ans)
``` | instruction | 0 | 93,418 | 23 | 186,836 |
Yes | output | 1 | 93,418 | 23 | 186,837 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
<image>
Arrange integers (0 or more and 99 or less) in a rhombus as illustrated in Fig. 1. Create a program that reads the data representing the rhombus and outputs the maximum value of the sum of the integers that pass when starting from the top and proceeding to the bottom according to the following rules.
* At each step, you can proceed to the lower left diagonal or the lower right diagonal.
For example, in the example of Fig. 1, as shown in Fig. 2, when 7,3,8,7,5,7,8,3,7 is selected and passed, the sum is the maximum 55 (7 + 3 + 8). + 7 + 5 + 7 + 8 + 3 + 7 = 55).
Input
As shown in the input example, a comma-separated sequence of integers is given to the diamond. Each line does not contain whitespace. The input example corresponds to Fig. 1. There are less than 100 rows of data.
Output
Outputs the maximum value of the sum of integers that pass according to the rules on one line.
Example
Input
7
3,8
8,1,0
2,7,4,4
4,5,2,6,5
2,7,4,4
8,1,0
3,8
7
Output
55
Submitted Solution:
```
count = 0
a = []
while(1):
try:
count += 1
a.append([int(i) for i in input().split(",")])
except EOFError:
break
dim = int(count/2)
b = [[0 for i in range(dim+1)] for j in range(dim+1)]
for i in range(dim):
for j in range(i+1):
b[i-j][j] = a[i][j]
for i in range(dim-1):
for j in range(dim-i-1):
b[dim-1-j][i+1+j] = a[i+dim][j]
dp_ = [[True if i < dim else 0 for i in range(dim+1)] if j < dim else [0 for i in range(dim+1)] for j in range(dim+1)]
def dp(i,j):
if dp_[i][j]:
dp_[i][j] = b[i][j] + max(dp(i+1,j),dp(i,j+1))
return dp_[i][j]
else:
return dp_[i][j]
print(dp(0,0))
``` | instruction | 0 | 93,419 | 23 | 186,838 |
No | output | 1 | 93,419 | 23 | 186,839 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
<image>
Arrange integers (0 or more and 99 or less) in a rhombus as illustrated in Fig. 1. Create a program that reads the data representing the rhombus and outputs the maximum value of the sum of the integers that pass when starting from the top and proceeding to the bottom according to the following rules.
* At each step, you can proceed to the lower left diagonal or the lower right diagonal.
For example, in the example of Fig. 1, as shown in Fig. 2, when 7,3,8,7,5,7,8,3,7 is selected and passed, the sum is the maximum 55 (7 + 3 + 8). + 7 + 5 + 7 + 8 + 3 + 7 = 55).
Input
As shown in the input example, a comma-separated sequence of integers is given to the diamond. Each line does not contain whitespace. The input example corresponds to Fig. 1. There are less than 100 rows of data.
Output
Outputs the maximum value of the sum of integers that pass according to the rules on one line.
Example
Input
7
3,8
8,1,0
2,7,4,4
4,5,2,6,5
2,7,4,4
8,1,0
3,8
7
Output
55
Submitted Solution:
```
def dmax(l):
for k in range(len(l)-1):
for (i,j) in enumerate(l[k]):
l[k+1].insert(2*i+1,j)
l[k+1]=[l[k+1][i+1]+j for (i,j) in enumerate(l[k+1][:-1])]
o=l[k+1][1:-1]
l[k+1]=[l[k+1][0]]+[o[i] if o[i]>=o[i+1] else o[i+1] for i in range(0,len(o),2)]+[l[k+1][-1]]
return max(l[-1])
cnt=0
l=[]
while 1:
t=list(map(int,input().split(",")))
l.extend([t])
if len(t)==1 and cnt>0:break
cnt+=1
b=len(l)//2+1
m=dmax(l[:b])+dmax(l[b:][::-1])
``` | instruction | 0 | 93,420 | 23 | 186,840 |
No | output | 1 | 93,420 | 23 | 186,841 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
<image>
Arrange integers (0 or more and 99 or less) in a rhombus as illustrated in Fig. 1. Create a program that reads the data representing the rhombus and outputs the maximum value of the sum of the integers that pass when starting from the top and proceeding to the bottom according to the following rules.
* At each step, you can proceed to the lower left diagonal or the lower right diagonal.
For example, in the example of Fig. 1, as shown in Fig. 2, when 7,3,8,7,5,7,8,3,7 is selected and passed, the sum is the maximum 55 (7 + 3 + 8). + 7 + 5 + 7 + 8 + 3 + 7 = 55).
Input
As shown in the input example, a comma-separated sequence of integers is given to the diamond. Each line does not contain whitespace. The input example corresponds to Fig. 1. There are less than 100 rows of data.
Output
Outputs the maximum value of the sum of integers that pass according to the rules on one line.
Example
Input
7
3,8
8,1,0
2,7,4,4
4,5,2,6,5
2,7,4,4
8,1,0
3,8
7
Output
55
Submitted Solution:
```
import sys
s=[list(map(int,e.split(',')))for e in sys.stdin]
for i in range(1,len(s)):
for j in range(len(s[i])):
t=j-len(s[i])>len(s[i-1])
s[i][j]+=max(s[i-1][t*(j>0):t+2])
print(*s[-1])
``` | instruction | 0 | 93,421 | 23 | 186,842 |
No | output | 1 | 93,421 | 23 | 186,843 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
<image>
Arrange integers (0 or more and 99 or less) in a rhombus as illustrated in Fig. 1. Create a program that reads the data representing the rhombus and outputs the maximum value of the sum of the integers that pass when starting from the top and proceeding to the bottom according to the following rules.
* At each step, you can proceed to the lower left diagonal or the lower right diagonal.
For example, in the example of Fig. 1, as shown in Fig. 2, when 7,3,8,7,5,7,8,3,7 is selected and passed, the sum is the maximum 55 (7 + 3 + 8). + 7 + 5 + 7 + 8 + 3 + 7 = 55).
Input
As shown in the input example, a comma-separated sequence of integers is given to the diamond. Each line does not contain whitespace. The input example corresponds to Fig. 1. There are less than 100 rows of data.
Output
Outputs the maximum value of the sum of integers that pass according to the rules on one line.
Example
Input
7
3,8
8,1,0
2,7,4,4
4,5,2,6,5
2,7,4,4
8,1,0
3,8
7
Output
55
Submitted Solution:
```
path=[]
while(True):
try:
temp=list(map(int,input().split(',')))
path.append(temp)
except:
break
``` | instruction | 0 | 93,422 | 23 | 186,844 |
No | output | 1 | 93,422 | 23 | 186,845 |
Provide a correct Python 3 solution for this coding contest problem.
Open Binary and Object Group organizes a programming contest every year. Mr. Hex belongs to this group and joins the judge team of the contest. This year, he created a geometric problem with its solution for the contest. The problem required a set of points forming a line-symmetric polygon for the input. Preparing the input for this problem was also his task. The input was expected to cover all edge cases, so he spent much time and attention to make them satisfactory.
However, since he worked with lots of care and for a long time, he got tired before he finished. So He might have made mistakes - there might be polygons not meeting the condition. It was not reasonable to prepare the input again from scratch. The judge team thus decided to find all line-asymmetric polygons in his input and fix them as soon as possible. They asked a programmer, just you, to write a program to find incorrect polygons.
You can assume the following:
* Edges of the polygon must not cross or touch each other except for the end points of adjacent edges.
* It is acceptable for the polygon to have adjacent three vertexes on a line, but in such a case, there must be the vertex symmetric to each of them.
Input
The input consists of a set of points in the following format.
N
x1 y1
x2 y2
...
xN yN
The first line of the input contains an integer N (3 β€ N β€ 1000), which denotes the number of points. The following N lines describe each point. The i-th line contains two integers x1, y1 (-10000 β€ xi, yi β€ 10000), which denote the coordinates of the i-th point.
Note that, although the points are the vertexes of a polygon, they are given in an artibrary order, not necessarily clockwise or counterclockwise.
Output
Output "Yes" in a line if the points can form a line-symmetric polygon, otherwise output "No".
Examples
Input
4
0 1
1 0
0 0
1 1
Output
Yes
Input
4
0 1
1 -1
0 0
1 1
Output
No
Input
9
-1 1
0 1
1 1
-1 0
0 0
1 0
-1 -1
0 -1
1 -1
Output
No
Input
3
-1 -1
0 0
1 1
Output
No
Input
4
0 2
0 0
-1 0
1 0
Output
Yes | instruction | 0 | 93,478 | 23 | 186,956 |
"Correct Solution:
```
from collections import defaultdict
import sys
readline = sys.stdin.readline
write = sys.stdout.write
def gcd(m, n):
while n:
m, n = n, m % n
return m
def solve():
N = int(readline())
P = [list(map(int, readline().split())) for i in range(N)]
ok = 0
x0, y0 = P[0]; x1, y1 = P[1]
for i in range(2, N):
x2, y2 = P[i]
if (x1 - x0) * (y2 - y0) != (x2 - x0) * (y1 - y0):
ok = 1
break
if not ok:
write("No\n")
return
A = defaultdict(int)
B = defaultdict(int)
for i in range(N):
xi, yi = P[i]
for j in range(i):
xj, yj = P[j]
dx = xi - xj; dy = yi - yj
g = gcd(abs(dx), abs(dy))
dx //= g; dy //= g
if dy < 0:
dx = -dx; dy = -dy
if dx == 0:
p = xi * dy - yi * dx; q = dy
g = gcd(abs(p), abs(q))
p //= g; q //= g
if q < 0:
q = -q; p = -p
key = (p, 0, q, dx, dy)
else:
p = yi * dx - xi * dy; q = dx
g = gcd(abs(p), abs(q))
p //= g; q //= g
if q < 0:
q = -q; p = -p
key = (0, p, q, dx, dy)
A[key] += 1
gx = -dy; gy = dx
if gy < 0:
gx = -gx; gy = -gy
if dy == 0:
p = dy * (yi + yj) + dx * (xi + xj)
q = 2 * dx
g = gcd(abs(p), abs(q))
p //= g; q //= g
if q < 0:
q = -q; p = -p
key = (p, 0, q, gx, gy)
else:
p = dx * (xi + xj) + dy * (yi + yj)
q = 2 * dy
g = gcd(abs(p), abs(q))
p //= g; q //= g
if q < 0:
q = -q; p = -p
key = (0, p, q, gx, gy)
B[key] += 1
ok = 0
if N % 2 == 0:
for k, v in B.items():
if 2*v == N:
ok = 1
break
if 2*v == N-2:
if A[k] == 1:
ok = 1
break
else:
R = []
for k, v in B.items():
if 2*v+1 == N:
R.append(k)
ok = 0
for x0, y0, z0, dx, dy in R:
cnt = 0
for x, y in P:
if dy*(x*z0 - x0) == dx*(y*z0 - y0):
cnt += 1
if cnt == 1:
ok = 1
break
if ok:
write("Yes\n")
else:
write("No\n")
solve()
``` | output | 1 | 93,478 | 23 | 186,957 |
Provide tags and a correct Python 3 solution for this coding contest problem.
Since Sonya has just learned the basics of matrices, she decided to play with them a little bit.
Sonya imagined a new type of matrices that she called rhombic matrices. These matrices have exactly one zero, while all other cells have the Manhattan distance to the cell containing the zero. The cells with equal numbers have the form of a rhombus, that is why Sonya called this type so.
The Manhattan distance between two cells (x_1, y_1) and (x_2, y_2) is defined as |x_1 - x_2| + |y_1 - y_2|. For example, the Manhattan distance between the cells (5, 2) and (7, 1) equals to |5-7|+|2-1|=3.
<image> Example of a rhombic matrix.
Note that rhombic matrices are uniquely defined by n, m, and the coordinates of the cell containing the zero.
She drew a nΓ m rhombic matrix. She believes that you can not recreate the matrix if she gives you only the elements of this matrix in some arbitrary order (i.e., the sequence of nβ
m numbers). Note that Sonya will not give you n and m, so only the sequence of numbers in this matrix will be at your disposal.
Write a program that finds such an nΓ m rhombic matrix whose elements are the same as the elements in the sequence in some order.
Input
The first line contains a single integer t (1β€ tβ€ 10^6) β the number of cells in the matrix.
The second line contains t integers a_1, a_2, β¦, a_t (0β€ a_i< t) β the values in the cells in arbitrary order.
Output
In the first line, print two positive integers n and m (n Γ m = t) β the size of the matrix.
In the second line, print two integers x and y (1β€ xβ€ n, 1β€ yβ€ m) β the row number and the column number where the cell with 0 is located.
If there are multiple possible answers, print any of them. If there is no solution, print the single integer -1.
Examples
Input
20
1 0 2 3 5 3 2 1 3 2 3 1 4 2 1 4 2 3 2 4
Output
4 5
2 2
Input
18
2 2 3 2 4 3 3 3 0 2 4 2 1 3 2 1 1 1
Output
3 6
2 3
Input
6
2 1 0 2 1 2
Output
-1
Note
You can see the solution to the first example in the legend. You also can choose the cell (2, 2) for the cell where 0 is located. You also can choose a 5Γ 4 matrix with zero at (4, 2).
In the second example, there is a 3Γ 6 matrix, where the zero is located at (2, 3) there.
In the third example, a solution does not exist. | instruction | 0 | 93,528 | 23 | 187,056 |
Tags: brute force, constructive algorithms, implementation
Correct Solution:
```
import math
t = int(input())
L = [int(x) for x in input().split()]
L.sort()
ma = max(L)
S = 2*sum(L)
Div = []
for i in range(1,int(math.sqrt(t))+1):
if t%i == 0:
Div.append(i)
Div.append(t//i)
if len(Div) >= 2:
if Div[-1] == Div[-2]:
Div.pop()
Div.sort()
D = {}
for i in L:
if i in D:
D[i] += 1
else:
D[i] = 1
Candidates = []
for i in range(len(Div)):
n = Div[i]
m = Div[-i-1]
for j in range(ma,ma-m,-1):
if D.get(j,-1) > ma-j+1:
break
else:
j -= 1
good = ma-j
y = 1+(m-good)//2
x = m+n-ma-y
T = x+y
if y >= 1:
if y <= (m+1)//2:
if x <= (n+1)//2:
if m*(x*(x-1)+(n-x)*(n-x+1))+n*((T-x)*(T-x-1)+(m-T+x)*(m-T+x+1)) == S:
temp = []
for j in range(m*n):
temp.append(abs(1+(j%n)-x)+abs(1+(j//n)-y))
temp.sort()
if temp == L:
print(n,m)
print(x,y)
break
else:
print(-1)
``` | output | 1 | 93,528 | 23 | 187,057 |
Provide tags and a correct Python 3 solution for this coding contest problem.
Since Sonya has just learned the basics of matrices, she decided to play with them a little bit.
Sonya imagined a new type of matrices that she called rhombic matrices. These matrices have exactly one zero, while all other cells have the Manhattan distance to the cell containing the zero. The cells with equal numbers have the form of a rhombus, that is why Sonya called this type so.
The Manhattan distance between two cells (x_1, y_1) and (x_2, y_2) is defined as |x_1 - x_2| + |y_1 - y_2|. For example, the Manhattan distance between the cells (5, 2) and (7, 1) equals to |5-7|+|2-1|=3.
<image> Example of a rhombic matrix.
Note that rhombic matrices are uniquely defined by n, m, and the coordinates of the cell containing the zero.
She drew a nΓ m rhombic matrix. She believes that you can not recreate the matrix if she gives you only the elements of this matrix in some arbitrary order (i.e., the sequence of nβ
m numbers). Note that Sonya will not give you n and m, so only the sequence of numbers in this matrix will be at your disposal.
Write a program that finds such an nΓ m rhombic matrix whose elements are the same as the elements in the sequence in some order.
Input
The first line contains a single integer t (1β€ tβ€ 10^6) β the number of cells in the matrix.
The second line contains t integers a_1, a_2, β¦, a_t (0β€ a_i< t) β the values in the cells in arbitrary order.
Output
In the first line, print two positive integers n and m (n Γ m = t) β the size of the matrix.
In the second line, print two integers x and y (1β€ xβ€ n, 1β€ yβ€ m) β the row number and the column number where the cell with 0 is located.
If there are multiple possible answers, print any of them. If there is no solution, print the single integer -1.
Examples
Input
20
1 0 2 3 5 3 2 1 3 2 3 1 4 2 1 4 2 3 2 4
Output
4 5
2 2
Input
18
2 2 3 2 4 3 3 3 0 2 4 2 1 3 2 1 1 1
Output
3 6
2 3
Input
6
2 1 0 2 1 2
Output
-1
Note
You can see the solution to the first example in the legend. You also can choose the cell (2, 2) for the cell where 0 is located. You also can choose a 5Γ 4 matrix with zero at (4, 2).
In the second example, there is a 3Γ 6 matrix, where the zero is located at (2, 3) there.
In the third example, a solution does not exist. | instruction | 0 | 93,529 | 23 | 187,058 |
Tags: brute force, constructive algorithms, implementation
Correct Solution:
```
import functools
import time
def timer(func):
@functools.wraps(func)
def wrapper(*args, **kwargs):
stime = time.perf_counter()
res = func(*args, **kwargs)
elapsed = time.perf_counter() - stime
print(f"{func.__name__} in {elapsed:.4f} secs")
return res
return wrapper
class solver:
# @timer
def __init__(self):
t = int(input())
a = list(map(int, input().strip().split()))
def build(n, m, r, c):
if not (0 <= r and r < n and 0 <= c and c < m):
return []
ret = [0] * t
for i in range (n):
for j in range(m):
ret[abs(r - i) + abs(c - j)] += 1
return ret
a.sort()
h = [0] * t
amax = 0
for ai in a:
h[ai] += 1
amax = max(amax, ai)
r = 0
while r + 1 < t and h[r + 1] == (r + 1) * 4:
r += 1
n = 1
while n * n <= t:
for transposed in [False, True]:
if t % n == 0:
m = t // n
c = (n - 1 - r) + (m - 1 - amax)
f = build(n, m, r, c) if not transposed else build(n, m, c, r)
if h == f:
print(f"{n} {m}")
if not transposed:
print(f"{r + 1} {c + 1}")
else:
print(f"{c + 1} {r + 1}")
exit(0)
n += 1
print('-1')
solver()
``` | output | 1 | 93,529 | 23 | 187,059 |
Provide tags and a correct Python 3 solution for this coding contest problem.
Since Sonya has just learned the basics of matrices, she decided to play with them a little bit.
Sonya imagined a new type of matrices that she called rhombic matrices. These matrices have exactly one zero, while all other cells have the Manhattan distance to the cell containing the zero. The cells with equal numbers have the form of a rhombus, that is why Sonya called this type so.
The Manhattan distance between two cells (x_1, y_1) and (x_2, y_2) is defined as |x_1 - x_2| + |y_1 - y_2|. For example, the Manhattan distance between the cells (5, 2) and (7, 1) equals to |5-7|+|2-1|=3.
<image> Example of a rhombic matrix.
Note that rhombic matrices are uniquely defined by n, m, and the coordinates of the cell containing the zero.
She drew a nΓ m rhombic matrix. She believes that you can not recreate the matrix if she gives you only the elements of this matrix in some arbitrary order (i.e., the sequence of nβ
m numbers). Note that Sonya will not give you n and m, so only the sequence of numbers in this matrix will be at your disposal.
Write a program that finds such an nΓ m rhombic matrix whose elements are the same as the elements in the sequence in some order.
Input
The first line contains a single integer t (1β€ tβ€ 10^6) β the number of cells in the matrix.
The second line contains t integers a_1, a_2, β¦, a_t (0β€ a_i< t) β the values in the cells in arbitrary order.
Output
In the first line, print two positive integers n and m (n Γ m = t) β the size of the matrix.
In the second line, print two integers x and y (1β€ xβ€ n, 1β€ yβ€ m) β the row number and the column number where the cell with 0 is located.
If there are multiple possible answers, print any of them. If there is no solution, print the single integer -1.
Examples
Input
20
1 0 2 3 5 3 2 1 3 2 3 1 4 2 1 4 2 3 2 4
Output
4 5
2 2
Input
18
2 2 3 2 4 3 3 3 0 2 4 2 1 3 2 1 1 1
Output
3 6
2 3
Input
6
2 1 0 2 1 2
Output
-1
Note
You can see the solution to the first example in the legend. You also can choose the cell (2, 2) for the cell where 0 is located. You also can choose a 5Γ 4 matrix with zero at (4, 2).
In the second example, there is a 3Γ 6 matrix, where the zero is located at (2, 3) there.
In the third example, a solution does not exist. | instruction | 0 | 93,530 | 23 | 187,060 |
Tags: brute force, constructive algorithms, implementation
Correct Solution:
```
from collections import Counter as c
def maker(m, n, x, y, a):
small, larg = min(x, y), max(x, y)
k1 = [i + 1 for i in range(small)] + [small for i in range(small, larg)] + [small + larg - i - 1 for i in range(larg, small + larg)] + [0 for i in range(small + larg, a + 1)]
small, larg = min(x, n - y + 1), max(x, n - y + 1)
k2 = [i + 1 for i in range(small)] + [small for i in range(small, larg)] + [small + larg - i - 1 for i in range(larg, small + larg)] + [0 for i in range(small + larg, a + 1)]
small, larg = min(m - x + 1, n - y + 1), max(m - x + 1, n - y + 1)
k3 = [i + 1 for i in range(small)] + [small for i in range(small, larg)] + [small + larg - i - 1 for i in range(larg, small + larg)] + [0 for i in range(small + larg, a + 1)]
small, larg = m - x + 1, y
k4 = [i + 1 for i in range(small)] + [small for i in range(small, larg)] + [small + larg - i - 1 for i in range(larg, small + larg)] + [0 for i in range(small + larg, a + 1)]
k = [k1[i] + k2[i] + k3[i] + k4[i] for i in range(a + 1)]
for i in range(x):k[i] -= 1
for i in range(y):k[i] -= 1
for i in range(m - x + 1):k[i] -= 1
for i in range(n - y + 1):k[i] -= 1
k[0] = 1
return k
t, d = int(input()), dict(c(map(int, input().split())))
if t == 1:
if 0 in d:
print(1, 1)
print(1, 1)
else:
print(-1)
else:
if any([i not in d for i in range(max(d))]):
print(-1)
else:
n, a, l, flag = int(t ** .5) + 1, max(d), [], False
d = [d[i] for i in range(a + 1)]
if d[0] != 1:
print(-1)
flag = True
if not flag:
for index in range(1, a + 1):
if d[index] > 4 * index:
print(-1)
flag = True
if d[index] < index * 4:
break
if not flag:
for m in range(2 * index - 1, n):
if not t % m:
n = t // m
if (m + n) // 2 <= a <= m + n - 2 and 2 * index - 1 <= n:
l.append((m, n))
for m, n in l:
t = [(m - index + 1, a + index + 1 - m), (a + index + 1 - n, n - index + 1)]
for x, y in t:
if m // 2 < x <= m and n // 2 < y <= n:
if d == maker(m, n, x, y, a):
print(m, n)
print(x, y)
flag = True
break
if flag:break
else:
print(-1)
``` | output | 1 | 93,530 | 23 | 187,061 |
Provide tags and a correct Python 3 solution for this coding contest problem.
Since Sonya has just learned the basics of matrices, she decided to play with them a little bit.
Sonya imagined a new type of matrices that she called rhombic matrices. These matrices have exactly one zero, while all other cells have the Manhattan distance to the cell containing the zero. The cells with equal numbers have the form of a rhombus, that is why Sonya called this type so.
The Manhattan distance between two cells (x_1, y_1) and (x_2, y_2) is defined as |x_1 - x_2| + |y_1 - y_2|. For example, the Manhattan distance between the cells (5, 2) and (7, 1) equals to |5-7|+|2-1|=3.
<image> Example of a rhombic matrix.
Note that rhombic matrices are uniquely defined by n, m, and the coordinates of the cell containing the zero.
She drew a nΓ m rhombic matrix. She believes that you can not recreate the matrix if she gives you only the elements of this matrix in some arbitrary order (i.e., the sequence of nβ
m numbers). Note that Sonya will not give you n and m, so only the sequence of numbers in this matrix will be at your disposal.
Write a program that finds such an nΓ m rhombic matrix whose elements are the same as the elements in the sequence in some order.
Input
The first line contains a single integer t (1β€ tβ€ 10^6) β the number of cells in the matrix.
The second line contains t integers a_1, a_2, β¦, a_t (0β€ a_i< t) β the values in the cells in arbitrary order.
Output
In the first line, print two positive integers n and m (n Γ m = t) β the size of the matrix.
In the second line, print two integers x and y (1β€ xβ€ n, 1β€ yβ€ m) β the row number and the column number where the cell with 0 is located.
If there are multiple possible answers, print any of them. If there is no solution, print the single integer -1.
Examples
Input
20
1 0 2 3 5 3 2 1 3 2 3 1 4 2 1 4 2 3 2 4
Output
4 5
2 2
Input
18
2 2 3 2 4 3 3 3 0 2 4 2 1 3 2 1 1 1
Output
3 6
2 3
Input
6
2 1 0 2 1 2
Output
-1
Note
You can see the solution to the first example in the legend. You also can choose the cell (2, 2) for the cell where 0 is located. You also can choose a 5Γ 4 matrix with zero at (4, 2).
In the second example, there is a 3Γ 6 matrix, where the zero is located at (2, 3) there.
In the third example, a solution does not exist. | instruction | 0 | 93,531 | 23 | 187,062 |
Tags: brute force, constructive algorithms, implementation
Correct Solution:
```
def get(n,m,a,b,t):
freq=[0]*(t+1)
for i in range(n):
for j in range(m):
val=abs(i-a)+abs(j-b)
freq[val]+=1
return freq
t=int(input())
a=list(map(int,input().split()))
mx=max(a)
f=[0]*(t+1)
for i in a:
f[i]+=1
b=1
for i in range(1,mx+1):
if f[i]!=4*i:
b=i
break
n=1
a=-1
x=0
y=0
mila=False
while n*n<=t:
if t%n==0:
m=t//n
a=n+m-mx-b
x,y=n,m
if a>0 and a<=n and b>0 and b<=m and f==get(n,m,a-1,b-1,t):
mila=True
break
if a>0 and a<=m and b>0 and b<=n and f==get(n,m,b-1,a-1,t):
mila=True
a,b=b,a
break
n+=1
if not mila:
print(-1)
else:
print(x,y)
print(a,b)
``` | output | 1 | 93,531 | 23 | 187,063 |
Provide tags and a correct Python 3 solution for this coding contest problem.
Since Sonya has just learned the basics of matrices, she decided to play with them a little bit.
Sonya imagined a new type of matrices that she called rhombic matrices. These matrices have exactly one zero, while all other cells have the Manhattan distance to the cell containing the zero. The cells with equal numbers have the form of a rhombus, that is why Sonya called this type so.
The Manhattan distance between two cells (x_1, y_1) and (x_2, y_2) is defined as |x_1 - x_2| + |y_1 - y_2|. For example, the Manhattan distance between the cells (5, 2) and (7, 1) equals to |5-7|+|2-1|=3.
<image> Example of a rhombic matrix.
Note that rhombic matrices are uniquely defined by n, m, and the coordinates of the cell containing the zero.
She drew a nΓ m rhombic matrix. She believes that you can not recreate the matrix if she gives you only the elements of this matrix in some arbitrary order (i.e., the sequence of nβ
m numbers). Note that Sonya will not give you n and m, so only the sequence of numbers in this matrix will be at your disposal.
Write a program that finds such an nΓ m rhombic matrix whose elements are the same as the elements in the sequence in some order.
Input
The first line contains a single integer t (1β€ tβ€ 10^6) β the number of cells in the matrix.
The second line contains t integers a_1, a_2, β¦, a_t (0β€ a_i< t) β the values in the cells in arbitrary order.
Output
In the first line, print two positive integers n and m (n Γ m = t) β the size of the matrix.
In the second line, print two integers x and y (1β€ xβ€ n, 1β€ yβ€ m) β the row number and the column number where the cell with 0 is located.
If there are multiple possible answers, print any of them. If there is no solution, print the single integer -1.
Examples
Input
20
1 0 2 3 5 3 2 1 3 2 3 1 4 2 1 4 2 3 2 4
Output
4 5
2 2
Input
18
2 2 3 2 4 3 3 3 0 2 4 2 1 3 2 1 1 1
Output
3 6
2 3
Input
6
2 1 0 2 1 2
Output
-1
Note
You can see the solution to the first example in the legend. You also can choose the cell (2, 2) for the cell where 0 is located. You also can choose a 5Γ 4 matrix with zero at (4, 2).
In the second example, there is a 3Γ 6 matrix, where the zero is located at (2, 3) there.
In the third example, a solution does not exist. | instruction | 0 | 93,532 | 23 | 187,064 |
Tags: brute force, constructive algorithms, implementation
Correct Solution:
```
from math import sqrt
from collections import Counter
def f(h, w, y, x):
return h * w * (h + w - (x + y + 1) * 2) // 2 + h * x * (x + 1) + w * y * (y + 1)
def check(h, w, y, x, cnt):
for i in range(1, y + 1):
for j in range(i + 1, i + x + 1):
cnt[j] -= 1
for j in range(i, i + w - x):
cnt[j] -= 1
for i in range(h - y):
for j in range(i + 1, i + x + 1):
cnt[j] -= 1
for j in range(i, i + w - x):
cnt[j] -= 1
if any(cnt.values()):
return
print(f'{h} {w}\n{y+1} {int(x)+1}')
raise TabError
def getyx(h, w, tot, cnt):
b = (w - 1) * .5
c = h * (tot - h * (w * w - 2 * w * (1 - h) - 1) * .25)
for y in range((h + 3) // 2):
d = (c - h * y * (w * y - h * w + w))
if d >= 0:
x = b - sqrt(d) / h
if x.is_integer() and x >= 0.:
check(h, w, y, int(x), cnt.copy())
def main():
n, l = int(input()), list(map(int, input().split()))
cnt, r, R, tot = Counter(l), 1, max(l), sum(l)
for r in range(1, R + 1):
if cnt[r] < r * 4:
break
try:
for h in range(r * 2 - 1, int(sqrt(n)) + 1):
if not n % h:
w = n // h
if f(h, w, h // 2, w // 2) <= tot <= f(h, w, 0, 0):
getyx(h, w, tot, cnt)
except TabError:
return
print(-1)
if __name__ == '__main__':
main()
``` | output | 1 | 93,532 | 23 | 187,065 |
Provide tags and a correct Python 3 solution for this coding contest problem.
Since Sonya has just learned the basics of matrices, she decided to play with them a little bit.
Sonya imagined a new type of matrices that she called rhombic matrices. These matrices have exactly one zero, while all other cells have the Manhattan distance to the cell containing the zero. The cells with equal numbers have the form of a rhombus, that is why Sonya called this type so.
The Manhattan distance between two cells (x_1, y_1) and (x_2, y_2) is defined as |x_1 - x_2| + |y_1 - y_2|. For example, the Manhattan distance between the cells (5, 2) and (7, 1) equals to |5-7|+|2-1|=3.
<image> Example of a rhombic matrix.
Note that rhombic matrices are uniquely defined by n, m, and the coordinates of the cell containing the zero.
She drew a nΓ m rhombic matrix. She believes that you can not recreate the matrix if she gives you only the elements of this matrix in some arbitrary order (i.e., the sequence of nβ
m numbers). Note that Sonya will not give you n and m, so only the sequence of numbers in this matrix will be at your disposal.
Write a program that finds such an nΓ m rhombic matrix whose elements are the same as the elements in the sequence in some order.
Input
The first line contains a single integer t (1β€ tβ€ 10^6) β the number of cells in the matrix.
The second line contains t integers a_1, a_2, β¦, a_t (0β€ a_i< t) β the values in the cells in arbitrary order.
Output
In the first line, print two positive integers n and m (n Γ m = t) β the size of the matrix.
In the second line, print two integers x and y (1β€ xβ€ n, 1β€ yβ€ m) β the row number and the column number where the cell with 0 is located.
If there are multiple possible answers, print any of them. If there is no solution, print the single integer -1.
Examples
Input
20
1 0 2 3 5 3 2 1 3 2 3 1 4 2 1 4 2 3 2 4
Output
4 5
2 2
Input
18
2 2 3 2 4 3 3 3 0 2 4 2 1 3 2 1 1 1
Output
3 6
2 3
Input
6
2 1 0 2 1 2
Output
-1
Note
You can see the solution to the first example in the legend. You also can choose the cell (2, 2) for the cell where 0 is located. You also can choose a 5Γ 4 matrix with zero at (4, 2).
In the second example, there is a 3Γ 6 matrix, where the zero is located at (2, 3) there.
In the third example, a solution does not exist. | instruction | 0 | 93,533 | 23 | 187,066 |
Tags: brute force, constructive algorithms, implementation
Correct Solution:
```
import sys
from collections import Counter
from itertools import chain
def i_ints():
return map(int, sys.stdin.readline().split())
def check(w, h, x, y, c):
counts = Counter(chain.from_iterable(range(abs(i-x), abs(i-x)+y) for i in range(1, w+1)))
counts += Counter(chain.from_iterable(range(abs(i-x)+1, abs(i-x)+1+(h-y)) for i in range(1, w+1)))
return c == counts
t, = i_ints()
a = Counter(i_ints())
i = 0
for i in range(1, t+1):
if a[i] != 4 * i:
break
x = i
B = max(a)
def main():
for w in range(2*x-1, int(t**0.5)+2):
if t % w:
continue
h = t // w
y = w + h - B - x
if y >= x and h >= 2*y-1 and check(w, h, x, y, a):
return "%s %s\n%s %s" % (w, h, x, y)
w, h = h, w
y = w + h - B - x
if y >= x and h >= 2*y-1 and check(w, h, x, y, a):
return "%s %s\n%s %s" % (w, h, x, y)
return -1
print(main())
``` | output | 1 | 93,533 | 23 | 187,067 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
Since Sonya has just learned the basics of matrices, she decided to play with them a little bit.
Sonya imagined a new type of matrices that she called rhombic matrices. These matrices have exactly one zero, while all other cells have the Manhattan distance to the cell containing the zero. The cells with equal numbers have the form of a rhombus, that is why Sonya called this type so.
The Manhattan distance between two cells (x_1, y_1) and (x_2, y_2) is defined as |x_1 - x_2| + |y_1 - y_2|. For example, the Manhattan distance between the cells (5, 2) and (7, 1) equals to |5-7|+|2-1|=3.
<image> Example of a rhombic matrix.
Note that rhombic matrices are uniquely defined by n, m, and the coordinates of the cell containing the zero.
She drew a nΓ m rhombic matrix. She believes that you can not recreate the matrix if she gives you only the elements of this matrix in some arbitrary order (i.e., the sequence of nβ
m numbers). Note that Sonya will not give you n and m, so only the sequence of numbers in this matrix will be at your disposal.
Write a program that finds such an nΓ m rhombic matrix whose elements are the same as the elements in the sequence in some order.
Input
The first line contains a single integer t (1β€ tβ€ 10^6) β the number of cells in the matrix.
The second line contains t integers a_1, a_2, β¦, a_t (0β€ a_i< t) β the values in the cells in arbitrary order.
Output
In the first line, print two positive integers n and m (n Γ m = t) β the size of the matrix.
In the second line, print two integers x and y (1β€ xβ€ n, 1β€ yβ€ m) β the row number and the column number where the cell with 0 is located.
If there are multiple possible answers, print any of them. If there is no solution, print the single integer -1.
Examples
Input
20
1 0 2 3 5 3 2 1 3 2 3 1 4 2 1 4 2 3 2 4
Output
4 5
2 2
Input
18
2 2 3 2 4 3 3 3 0 2 4 2 1 3 2 1 1 1
Output
3 6
2 3
Input
6
2 1 0 2 1 2
Output
-1
Note
You can see the solution to the first example in the legend. You also can choose the cell (2, 2) for the cell where 0 is located. You also can choose a 5Γ 4 matrix with zero at (4, 2).
In the second example, there is a 3Γ 6 matrix, where the zero is located at (2, 3) there.
In the third example, a solution does not exist.
Submitted Solution:
```
from collections import Counter as c
def xsum(h, w, x, y):
return h * w * (h + w - (x + y + 1) * 2) // 2 + w * x * (x + 1) + h * y * (y + 1)
def maker(m, n, x, y, a):
small, larg = min(x, y), max(x, y)
k1 = [i + 1 for i in range(small)] + [small for i in range(small, larg)] + [small + larg - i - 1 for i in range(larg, small + larg)] + [0 for i in range(small + larg, a + 1)]
small, larg = min(x, n - y + 1), max(x, n - y + 1)
k2 = [i + 1 for i in range(small)] + [small for i in range(small, larg)] + [small + larg - i - 1 for i in range(larg, small + larg)] + [0 for i in range(small + larg, a + 1)]
small, larg = min(m - x + 1, n - y + 1), max(m - x + 1, n - y + 1)
k3 = [i + 1 for i in range(small)] + [small for i in range(small, larg)] + [small + larg - i - 1 for i in range(larg, small + larg)] + [0 for i in range(small + larg, a + 1)]
small, larg = m - x + 1, y
k4 = [i + 1 for i in range(small)] + [small for i in range(small, larg)] + [small + larg - i - 1 for i in range(larg, small + larg)] + [0 for i in range(small + larg, a + 1)]
k = [k1[i] + k2[i] + k3[i] + k4[i] for i in range(a + 1)]
for i in range(x):k[i] -= 1
for i in range(y):k[i] -= 1
for i in range(a-x+1):k[i] -= 1
for i in range(b-y+1):k[i] -= 1
k[0] = 0
return k
t, d = int(input()), dict(c(map(int, input().split())))
n, a, l = int(t ** .5) + 1, max(d), []
d = [d[i] for i in range(a + 1)]
tot = sum([i * d[i] for i in range(a + 1)])
if d[0] != 1:
print(-1)
exit()
for index in range(1, a + 1):
if d[index] > 4 * index:
print(-1)
exit()
if d[index] < index * 4:
break
for m in range(2 * index - 1, n):
if not t % m:
n = t // m
if (m + n) // 2 <= a <= m + n - 2 and 2 * index - 1 <= n and xsum(m, n, m // 2, n // 2) <= tot <= xsum(m, n, 0, 0):
l.append((m, n))
for m, n in l:
t = [(m - index + 1, a + index + 1 - m), (a + index + 1 - n, n - index + 1)]
for x, y in t:
if m // 2 < x <= m and n // 2 < y <= n and xsum(m, n, x, y) == tot:
if d == maker(m, n, x, y, a):
print(m, n)
print(x, y)
exit()
else:
print(-1)
``` | instruction | 0 | 93,534 | 23 | 187,068 |
No | output | 1 | 93,534 | 23 | 187,069 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
Since Sonya has just learned the basics of matrices, she decided to play with them a little bit.
Sonya imagined a new type of matrices that she called rhombic matrices. These matrices have exactly one zero, while all other cells have the Manhattan distance to the cell containing the zero. The cells with equal numbers have the form of a rhombus, that is why Sonya called this type so.
The Manhattan distance between two cells (x_1, y_1) and (x_2, y_2) is defined as |x_1 - x_2| + |y_1 - y_2|. For example, the Manhattan distance between the cells (5, 2) and (7, 1) equals to |5-7|+|2-1|=3.
<image> Example of a rhombic matrix.
Note that rhombic matrices are uniquely defined by n, m, and the coordinates of the cell containing the zero.
She drew a nΓ m rhombic matrix. She believes that you can not recreate the matrix if she gives you only the elements of this matrix in some arbitrary order (i.e., the sequence of nβ
m numbers). Note that Sonya will not give you n and m, so only the sequence of numbers in this matrix will be at your disposal.
Write a program that finds such an nΓ m rhombic matrix whose elements are the same as the elements in the sequence in some order.
Input
The first line contains a single integer t (1β€ tβ€ 10^6) β the number of cells in the matrix.
The second line contains t integers a_1, a_2, β¦, a_t (0β€ a_i< t) β the values in the cells in arbitrary order.
Output
In the first line, print two positive integers n and m (n Γ m = t) β the size of the matrix.
In the second line, print two integers x and y (1β€ xβ€ n, 1β€ yβ€ m) β the row number and the column number where the cell with 0 is located.
If there are multiple possible answers, print any of them. If there is no solution, print the single integer -1.
Examples
Input
20
1 0 2 3 5 3 2 1 3 2 3 1 4 2 1 4 2 3 2 4
Output
4 5
2 2
Input
18
2 2 3 2 4 3 3 3 0 2 4 2 1 3 2 1 1 1
Output
3 6
2 3
Input
6
2 1 0 2 1 2
Output
-1
Note
You can see the solution to the first example in the legend. You also can choose the cell (2, 2) for the cell where 0 is located. You also can choose a 5Γ 4 matrix with zero at (4, 2).
In the second example, there is a 3Γ 6 matrix, where the zero is located at (2, 3) there.
In the third example, a solution does not exist.
Submitted Solution:
```
from collections import Counter as c
def area(h, w, x, y):
return h * w * (h + w - (x + y + 1) * 2) // 2 + w * x * (x + 1) + h * y * (y + 1)
t, d = int(input()), dict(c(map(int, input().split())))
n, a, l, flag = int(t ** .5) + 1, max(d), [], False
d = [d[i] for i in range(a + 1)]
tot = sum([i * d[i] for i in range(a + 1)])
if d[0] != 1:
print(-1)
exit()
for i in range(1, a + 1):
if d[i] > 4 * i:
print(-1)
exit()
for index in range(1, a + 1):
if d[index] < index * 4:
break
for m in range(2 * index - 1, n):
if t % m == 0:
n = t // m
if (m + n) // 2 <= a <= m + n - 2 and 2 * index - 1 <= n and area(m, n, m // 2, n // 2) <= tot <= area(m, n, 0, 0):
l.append((m, n))
for m, n in l:
t = [(m - index + 1, a + index + 1 - m), (a + index + 1 - n, n - index + 1)]
for x, y in t:
if m // 2 < x <= m and n // 2 < y <= n and area(m, n, x, y) == tot:
for i in range(1, m + 1):
for j in range(1, n + 1):
d[abs(i - x) + abs(j - y)] -= 1
if set(d) == {0}:
print(m, n)
print(x, y)
flag = True
break
for i in range(1, m + 1):
for j in range(1, n + 1):
d[abs(i - x) + abs(j - y)] += 1
if flag:break
else:
print(-1)
``` | instruction | 0 | 93,535 | 23 | 187,070 |
No | output | 1 | 93,535 | 23 | 187,071 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
Since Sonya has just learned the basics of matrices, she decided to play with them a little bit.
Sonya imagined a new type of matrices that she called rhombic matrices. These matrices have exactly one zero, while all other cells have the Manhattan distance to the cell containing the zero. The cells with equal numbers have the form of a rhombus, that is why Sonya called this type so.
The Manhattan distance between two cells (x_1, y_1) and (x_2, y_2) is defined as |x_1 - x_2| + |y_1 - y_2|. For example, the Manhattan distance between the cells (5, 2) and (7, 1) equals to |5-7|+|2-1|=3.
<image> Example of a rhombic matrix.
Note that rhombic matrices are uniquely defined by n, m, and the coordinates of the cell containing the zero.
She drew a nΓ m rhombic matrix. She believes that you can not recreate the matrix if she gives you only the elements of this matrix in some arbitrary order (i.e., the sequence of nβ
m numbers). Note that Sonya will not give you n and m, so only the sequence of numbers in this matrix will be at your disposal.
Write a program that finds such an nΓ m rhombic matrix whose elements are the same as the elements in the sequence in some order.
Input
The first line contains a single integer t (1β€ tβ€ 10^6) β the number of cells in the matrix.
The second line contains t integers a_1, a_2, β¦, a_t (0β€ a_i< t) β the values in the cells in arbitrary order.
Output
In the first line, print two positive integers n and m (n Γ m = t) β the size of the matrix.
In the second line, print two integers x and y (1β€ xβ€ n, 1β€ yβ€ m) β the row number and the column number where the cell with 0 is located.
If there are multiple possible answers, print any of them. If there is no solution, print the single integer -1.
Examples
Input
20
1 0 2 3 5 3 2 1 3 2 3 1 4 2 1 4 2 3 2 4
Output
4 5
2 2
Input
18
2 2 3 2 4 3 3 3 0 2 4 2 1 3 2 1 1 1
Output
3 6
2 3
Input
6
2 1 0 2 1 2
Output
-1
Note
You can see the solution to the first example in the legend. You also can choose the cell (2, 2) for the cell where 0 is located. You also can choose a 5Γ 4 matrix with zero at (4, 2).
In the second example, there is a 3Γ 6 matrix, where the zero is located at (2, 3) there.
In the third example, a solution does not exist.
Submitted Solution:
```
from collections import defaultdict
import math
s = int(input())
ls = [int(i) for i in input().split()]
cnt = defaultdict(int)
for i in ls:
cnt[i] += 1
b = max(ls)
y, n, m = -1, -1, -1
x = 1
while cnt[x] == 4 * x:
x += 1
f = int(math.sqrt(s))
for i in range(x, s+1):
if i > f:
break
if s % i != 0:
continue
n, m = i, s // i
# if n + m - b - x < m:
# continue
y = n + m - b - x
if x - 1 + y - 1 != x:
y = -1
continue
break
if y == -1:
exit(print(-1))
print(n, ' ', m)
print(x, ' ', y)
``` | instruction | 0 | 93,536 | 23 | 187,072 |
No | output | 1 | 93,536 | 23 | 187,073 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
Since Sonya has just learned the basics of matrices, she decided to play with them a little bit.
Sonya imagined a new type of matrices that she called rhombic matrices. These matrices have exactly one zero, while all other cells have the Manhattan distance to the cell containing the zero. The cells with equal numbers have the form of a rhombus, that is why Sonya called this type so.
The Manhattan distance between two cells (x_1, y_1) and (x_2, y_2) is defined as |x_1 - x_2| + |y_1 - y_2|. For example, the Manhattan distance between the cells (5, 2) and (7, 1) equals to |5-7|+|2-1|=3.
<image> Example of a rhombic matrix.
Note that rhombic matrices are uniquely defined by n, m, and the coordinates of the cell containing the zero.
She drew a nΓ m rhombic matrix. She believes that you can not recreate the matrix if she gives you only the elements of this matrix in some arbitrary order (i.e., the sequence of nβ
m numbers). Note that Sonya will not give you n and m, so only the sequence of numbers in this matrix will be at your disposal.
Write a program that finds such an nΓ m rhombic matrix whose elements are the same as the elements in the sequence in some order.
Input
The first line contains a single integer t (1β€ tβ€ 10^6) β the number of cells in the matrix.
The second line contains t integers a_1, a_2, β¦, a_t (0β€ a_i< t) β the values in the cells in arbitrary order.
Output
In the first line, print two positive integers n and m (n Γ m = t) β the size of the matrix.
In the second line, print two integers x and y (1β€ xβ€ n, 1β€ yβ€ m) β the row number and the column number where the cell with 0 is located.
If there are multiple possible answers, print any of them. If there is no solution, print the single integer -1.
Examples
Input
20
1 0 2 3 5 3 2 1 3 2 3 1 4 2 1 4 2 3 2 4
Output
4 5
2 2
Input
18
2 2 3 2 4 3 3 3 0 2 4 2 1 3 2 1 1 1
Output
3 6
2 3
Input
6
2 1 0 2 1 2
Output
-1
Note
You can see the solution to the first example in the legend. You also can choose the cell (2, 2) for the cell where 0 is located. You also can choose a 5Γ 4 matrix with zero at (4, 2).
In the second example, there is a 3Γ 6 matrix, where the zero is located at (2, 3) there.
In the third example, a solution does not exist.
Submitted Solution:
```
def get(n,m,a,b,t):
freq=[0]*(t+1)
for i in range(n):
for j in range(m):
val=abs(i-a)+abs(j-b)
freq[val]+=1
return freq
t=int(input())
a=list(map(int,input().split()))
mx=max(a)
f=[0]*(t+1)
for i in a:
f[i]+=1
b=-1
for i in range(1,mx+1):
if f[i]!=4*i:
b=i
break
n=1
a=-1
x=0
y=0
mila=False
while n*n<=t:
if t%n==0:
m=t//n
a=n+m-mx-b-2
x,y=n,m
if a>=0 and a<n and b>=0 and b<m and f==get(n,m,a,b,t):
mila=True
break
if a>=0 and a<m and b>=0 and b<n and f==get(n,m,b,a,t):
mila=True
a,b=b,a
break
n+=1
if not mila:
print(-1)
else:
print(x,y)
print(a+1,b+1)
``` | instruction | 0 | 93,537 | 23 | 187,074 |
No | output | 1 | 93,537 | 23 | 187,075 |
Provide tags and a correct Python 3 solution for this coding contest problem.
Nowadays all circuses in Berland have a round arena with diameter 13 meters, but in the past things were different.
In Ancient Berland arenas in circuses were shaped as a regular (equiangular) polygon, the size and the number of angles could vary from one circus to another. In each corner of the arena there was a special pillar, and the rope strung between the pillars marked the arena edges.
Recently the scientists from Berland have discovered the remains of the ancient circus arena. They found only three pillars, the others were destroyed by the time.
You are given the coordinates of these three pillars. Find out what is the smallest area that the arena could have.
Input
The input file consists of three lines, each of them contains a pair of numbers ββ coordinates of the pillar. Any coordinate doesn't exceed 1000 by absolute value, and is given with at most six digits after decimal point.
Output
Output the smallest possible area of the ancient arena. This number should be accurate to at least 6 digits after the decimal point. It's guaranteed that the number of angles in the optimal polygon is not larger than 100.
Examples
Input
0.000000 0.000000
1.000000 1.000000
0.000000 1.000000
Output
1.00000000 | instruction | 0 | 93,779 | 23 | 187,558 |
Tags: geometry, math
Correct Solution:
```
import math
EPSILON = 0.0001
def radians(x1, y1, x2, y2):
product = x1*x2 + y1*y2
norm1 = (x1*x1+y1*y1) ** 0.5
norm2 = (x2*x2+y2*y2) ** 0.5
cosVal = max(-1, min(1, product/norm1/norm2))
return math.acos(cosVal)
x1, y1 = map(float, input().split(" "))
x2, y2 = map(float, input().split(" "))
x3, y3 = map(float, input().split(" "))
a, b, c, d = x1-x2, y1-y2, x1-x3, y1-y3
e = ((x1*x1-x2*x2) - (y2*y2-y1*y1)) / 2
f = ((x1*x1-x3*x3) - (y3*y3-y1*y1)) / 2
ox = -(d*e-b*f)/(b*c-a*d)
oy = -(a*f-c*e)/(b*c-a*d)
alpha1 = radians(x1-ox, y1-oy, x2-ox, y2-oy)
alpha2 = radians(x1-ox, y1-oy, x3-ox, y3-oy)
for i in range(3, 101):
unit = 2*math.pi/i
if abs(alpha1/unit - round(alpha1/unit)) > EPSILON:
continue
if abs(alpha2/unit - round(alpha2/unit)) > EPSILON:
continue
radius = ((x1-ox)**2 + (y1-oy)**2) ** 0.5
area = 0.5 * radius * radius * math.sin(unit) * i;
print(area)
exit()
``` | output | 1 | 93,779 | 23 | 187,559 |
Provide tags and a correct Python 3 solution for this coding contest problem.
Nowadays all circuses in Berland have a round arena with diameter 13 meters, but in the past things were different.
In Ancient Berland arenas in circuses were shaped as a regular (equiangular) polygon, the size and the number of angles could vary from one circus to another. In each corner of the arena there was a special pillar, and the rope strung between the pillars marked the arena edges.
Recently the scientists from Berland have discovered the remains of the ancient circus arena. They found only three pillars, the others were destroyed by the time.
You are given the coordinates of these three pillars. Find out what is the smallest area that the arena could have.
Input
The input file consists of three lines, each of them contains a pair of numbers ββ coordinates of the pillar. Any coordinate doesn't exceed 1000 by absolute value, and is given with at most six digits after decimal point.
Output
Output the smallest possible area of the ancient arena. This number should be accurate to at least 6 digits after the decimal point. It's guaranteed that the number of angles in the optimal polygon is not larger than 100.
Examples
Input
0.000000 0.000000
1.000000 1.000000
0.000000 1.000000
Output
1.00000000 | instruction | 0 | 93,780 | 23 | 187,560 |
Tags: geometry, math
Correct Solution:
```
from math import *
def rt(x, y):
return sum((i - j) ** 2 for i, j in zip(x, y))
def tr(a, b, c):
return acos((b + c - a) / (2 * (b * c) ** 0.5)) / pi
def trt(x, n):
return 0.01 < (x * n) % 1 < 0.99
x, y, z = (tuple(map(float, input().split())) for i in range(3))
a, b, c = rt(x, y), rt(x, z), rt(y, z)
t, s = tr(a, b, c), tr(b, a, c)
r, n = a / (8 * sin(t * pi) ** 2), 3
while trt(t, n) or trt(s, n): n += 1
print(n * r * sin(2 * pi / n))
``` | output | 1 | 93,780 | 23 | 187,561 |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.