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.
Pasha has a wooden stick of some positive integer length n. He wants to perform exactly three cuts to get four parts of the stick. Each part must have some positive integer length and the sum of these lengths will obviously be n.
Pasha likes rectangles but hates squares, so he wonders, how many ways are there to split a stick into four parts so that it's possible to form a rectangle using these parts, but is impossible to form a square.
Your task is to help Pasha and count the number of such ways. Two ways to cut the stick are considered distinct if there exists some integer x, such that the number of parts of length x in the first way differ from the number of parts of length x in the second way.
Input
The first line of the input contains a positive integer n (1 ≤ n ≤ 2·109) — the length of Pasha's stick.
Output
The output should contain a single integer — the number of ways to split Pasha's stick into four parts of positive integer length so that it's possible to make a rectangle by connecting the ends of these parts, but is impossible to form a square.
Examples
Input
6
Output
1
Input
20
Output
4
Note
There is only one way to divide the stick in the first sample {1, 1, 2, 2}.
Four ways to divide the stick in the second sample are {1, 1, 9, 9}, {2, 2, 8, 8}, {3, 3, 7, 7} and {4, 4, 6, 6}. Note that {5, 5, 5, 5} doesn't work.
Submitted Solution:
```
# Author : nitish420 --------------------------------------------------------------------
import os
import sys
from io import BytesIO, IOBase
def main():
n=int(input())
if n%2:
print(0)
else:
if n%4==0:
print(n//4-1)
else:
print(n//4)
#----------------------------------------------------------------------------------------
# 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')
sys.stdin, sys.stdout = IOWrapper(sys.stdin), IOWrapper(sys.stdout)
input = lambda: sys.stdin.readline().rstrip('\r\n')
# endregion
if __name__ == '__main__':
main()
``` | instruction | 0 | 77,146 | 23 | 154,292 |
Yes | output | 1 | 77,146 | 23 | 154,293 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
Pasha has a wooden stick of some positive integer length n. He wants to perform exactly three cuts to get four parts of the stick. Each part must have some positive integer length and the sum of these lengths will obviously be n.
Pasha likes rectangles but hates squares, so he wonders, how many ways are there to split a stick into four parts so that it's possible to form a rectangle using these parts, but is impossible to form a square.
Your task is to help Pasha and count the number of such ways. Two ways to cut the stick are considered distinct if there exists some integer x, such that the number of parts of length x in the first way differ from the number of parts of length x in the second way.
Input
The first line of the input contains a positive integer n (1 ≤ n ≤ 2·109) — the length of Pasha's stick.
Output
The output should contain a single integer — the number of ways to split Pasha's stick into four parts of positive integer length so that it's possible to make a rectangle by connecting the ends of these parts, but is impossible to form a square.
Examples
Input
6
Output
1
Input
20
Output
4
Note
There is only one way to divide the stick in the first sample {1, 1, 2, 2}.
Four ways to divide the stick in the second sample are {1, 1, 9, 9}, {2, 2, 8, 8}, {3, 3, 7, 7} and {4, 4, 6, 6}. Note that {5, 5, 5, 5} doesn't work.
Submitted Solution:
```
n=int(input())
if n%2==1:
ans=0
else:
c=n/2
if c%2==1:
ans=int(n/4)
else:
ans=n/4-1
print(ans)
``` | instruction | 0 | 77,147 | 23 | 154,294 |
No | output | 1 | 77,147 | 23 | 154,295 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
Pasha has a wooden stick of some positive integer length n. He wants to perform exactly three cuts to get four parts of the stick. Each part must have some positive integer length and the sum of these lengths will obviously be n.
Pasha likes rectangles but hates squares, so he wonders, how many ways are there to split a stick into four parts so that it's possible to form a rectangle using these parts, but is impossible to form a square.
Your task is to help Pasha and count the number of such ways. Two ways to cut the stick are considered distinct if there exists some integer x, such that the number of parts of length x in the first way differ from the number of parts of length x in the second way.
Input
The first line of the input contains a positive integer n (1 ≤ n ≤ 2·109) — the length of Pasha's stick.
Output
The output should contain a single integer — the number of ways to split Pasha's stick into four parts of positive integer length so that it's possible to make a rectangle by connecting the ends of these parts, but is impossible to form a square.
Examples
Input
6
Output
1
Input
20
Output
4
Note
There is only one way to divide the stick in the first sample {1, 1, 2, 2}.
Four ways to divide the stick in the second sample are {1, 1, 9, 9}, {2, 2, 8, 8}, {3, 3, 7, 7} and {4, 4, 6, 6}. Note that {5, 5, 5, 5} doesn't work.
Submitted Solution:
```
# cf 610 A 1000
n = int(input())
# a + b + c + d s.t. !(a == b == c == d)
base = n // 4
if n % 4 == 0:
base -= 1
print(base)
``` | instruction | 0 | 77,148 | 23 | 154,296 |
No | output | 1 | 77,148 | 23 | 154,297 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
Pasha has a wooden stick of some positive integer length n. He wants to perform exactly three cuts to get four parts of the stick. Each part must have some positive integer length and the sum of these lengths will obviously be n.
Pasha likes rectangles but hates squares, so he wonders, how many ways are there to split a stick into four parts so that it's possible to form a rectangle using these parts, but is impossible to form a square.
Your task is to help Pasha and count the number of such ways. Two ways to cut the stick are considered distinct if there exists some integer x, such that the number of parts of length x in the first way differ from the number of parts of length x in the second way.
Input
The first line of the input contains a positive integer n (1 ≤ n ≤ 2·109) — the length of Pasha's stick.
Output
The output should contain a single integer — the number of ways to split Pasha's stick into four parts of positive integer length so that it's possible to make a rectangle by connecting the ends of these parts, but is impossible to form a square.
Examples
Input
6
Output
1
Input
20
Output
4
Note
There is only one way to divide the stick in the first sample {1, 1, 2, 2}.
Four ways to divide the stick in the second sample are {1, 1, 9, 9}, {2, 2, 8, 8}, {3, 3, 7, 7} and {4, 4, 6, 6}. Note that {5, 5, 5, 5} doesn't work.
Submitted Solution:
```
from sys import stdin,stdout
from heapq import heapify,heappush,heappop,heappushpop
from collections import defaultdict as dd, deque as dq,Counter as C
from bisect import bisect_left as bl ,bisect_right as br
from itertools import combinations as cmb,permutations as pmb
from math import factorial as f ,ceil,gcd,sqrt,log,inf
mi = lambda : map(int,input().split())
ii = lambda: int(input())
li = lambda : list(map(int,input().split()))
mati = lambda r : [ li() for _ in range(r)]
lcm = lambda a,b : (a*b)//gcd(a,b)
MOD=10**9+7
def soe(n):
prime = [True for i in range(n+1)]
p = 2
while (p * p <= n):
if (prime[p] == True):
for i in range(p * p, n+1, p):
prime[i] = False
p += 1
return(prime)
def ncr(n,r):
p,k=1,1
if (n - r < r):
r = n - r
if r!=0:
while(r):
p,k=p*n,k*r
m=gcd(p,k)
p,k=p//m,k//m
n,r=n-1,r-1
else:
p=1
return(p)
def solve():
n=ii()
print(ceil(ceil(n/2)/2)-1)
for _ in range(1):
solve()
``` | instruction | 0 | 77,149 | 23 | 154,298 |
No | output | 1 | 77,149 | 23 | 154,299 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
Pasha has a wooden stick of some positive integer length n. He wants to perform exactly three cuts to get four parts of the stick. Each part must have some positive integer length and the sum of these lengths will obviously be n.
Pasha likes rectangles but hates squares, so he wonders, how many ways are there to split a stick into four parts so that it's possible to form a rectangle using these parts, but is impossible to form a square.
Your task is to help Pasha and count the number of such ways. Two ways to cut the stick are considered distinct if there exists some integer x, such that the number of parts of length x in the first way differ from the number of parts of length x in the second way.
Input
The first line of the input contains a positive integer n (1 ≤ n ≤ 2·109) — the length of Pasha's stick.
Output
The output should contain a single integer — the number of ways to split Pasha's stick into four parts of positive integer length so that it's possible to make a rectangle by connecting the ends of these parts, but is impossible to form a square.
Examples
Input
6
Output
1
Input
20
Output
4
Note
There is only one way to divide the stick in the first sample {1, 1, 2, 2}.
Four ways to divide the stick in the second sample are {1, 1, 9, 9}, {2, 2, 8, 8}, {3, 3, 7, 7} and {4, 4, 6, 6}. Note that {5, 5, 5, 5} doesn't work.
Submitted Solution:
```
n = int(input().strip())
print(n//4-1 if n%4==0 else n//4)
``` | instruction | 0 | 77,150 | 23 | 154,300 |
No | output | 1 | 77,150 | 23 | 154,301 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
You are given a set of points on a straight line. Each point has a color assigned to it. For point a, its neighbors are the points which don't have any other points between them and a. Each point has at most two neighbors - one from the left and one from the right.
You perform a sequence of operations on this set of points. In one operation, you delete all points which have a neighbor point of a different color than the point itself. Points are deleted simultaneously, i.e. first you decide which points have to be deleted and then delete them. After that you can perform the next operation etc. If an operation would not delete any points, you can't perform it.
How many operations will you need to perform until the next operation does not have any points to delete?
Input
Input contains a single string of lowercase English letters 'a'-'z'. The letters give the points' colors in the order in which they are arranged on the line: the first letter gives the color of the leftmost point, the second gives the color of the second point from the left etc.
The number of the points is between 1 and 106.
Output
Output one line containing an integer - the number of operations which can be performed on the given set of points until there are no more points to delete.
Examples
Input
aabb
Output
2
Input
aabcaa
Output
1
Note
In the first test case, the first operation will delete two middle points and leave points "ab", which will be deleted with the second operation. There will be no points left to apply the third operation to.
In the second test case, the first operation will delete the four points in the middle, leaving points "aa". None of them have neighbors of other colors, so the second operation can't be applied.
Submitted Solution:
```
def deletePoints(s):
r=""
for i in range(len(s)-1):
if s[i]==s[i+1]:
r+=s[i]
if i==len(s)-2:
r+=s[i+1]
return r
s=input()
c=0
while deletePoints(s)!=s:
s=deletePoints(s)
c+=1
print(c)
``` | instruction | 0 | 77,964 | 23 | 155,928 |
No | output | 1 | 77,964 | 23 | 155,929 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
You are given a set of points on a straight line. Each point has a color assigned to it. For point a, its neighbors are the points which don't have any other points between them and a. Each point has at most two neighbors - one from the left and one from the right.
You perform a sequence of operations on this set of points. In one operation, you delete all points which have a neighbor point of a different color than the point itself. Points are deleted simultaneously, i.e. first you decide which points have to be deleted and then delete them. After that you can perform the next operation etc. If an operation would not delete any points, you can't perform it.
How many operations will you need to perform until the next operation does not have any points to delete?
Input
Input contains a single string of lowercase English letters 'a'-'z'. The letters give the points' colors in the order in which they are arranged on the line: the first letter gives the color of the leftmost point, the second gives the color of the second point from the left etc.
The number of the points is between 1 and 106.
Output
Output one line containing an integer - the number of operations which can be performed on the given set of points until there are no more points to delete.
Examples
Input
aabb
Output
2
Input
aabcaa
Output
1
Note
In the first test case, the first operation will delete two middle points and leave points "ab", which will be deleted with the second operation. There will be no points left to apply the third operation to.
In the second test case, the first operation will delete the four points in the middle, leaving points "aa". None of them have neighbors of other colors, so the second operation can't be applied.
Submitted Solution:
```
s = input()
n = 1
for i in range(1, len(s)):
if s[i] != s[i-1]:
n += 1
mas = [0] * n
col = [0] * n
count = 1
idx = 0
c = s[0]
for i in range(1, len(s)):
if s[i] == s[i-1]:
count += 1
else:
mas[idx] = count
idx += 1
count = 1
c = s[i]
mas[idx] = count
col[idx] = c
res = 0
while n > 1:
newlen = n
idx = -1
for i in range(0, n):
if (i == 0) or (i == n - 1):
mas[i] -= 1
elif mas[i] >= 2:
mas[i] -= 2
else:
mas[i] = 0
if mas[i] == 0:
newlen -= 1
else:
if idx >= 0 and col[idx] == col[i]:
mas[idx] += mas[i]
newlen -= 1
else:
idx += 1
mas[idx] = mas[i]
col[idx] = col[i]
type = i % 2
n = newlen
res += 1
print(res)
``` | instruction | 0 | 77,965 | 23 | 155,930 |
No | output | 1 | 77,965 | 23 | 155,931 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
You are given a 0-1 rectangular matrix. What is the number of squares in it? A square is a solid square frame (border) with linewidth equal to 1. A square should be at least 2 × 2. We are only interested in two types of squares:
1. squares with each side parallel to a side of the matrix;
2. squares with each side parallel to a diagonal of the matrix.
For example the following matrix contains only one square of the first type:
0000000
0111100
0100100
0100100
0111100
The following matrix contains only one square of the second type:
0000000
0010000
0101000
0010000
0000000
Regardless of type, a square must contain at least one 1 and can't touch (by side or corner) any foreign 1. Of course, the lengths of the sides of each square should be equal.
How many squares are in the given matrix?
Input
The first line contains integer t (1 ≤ t ≤ 10000), where t is the number of test cases in the input. Then test cases follow. Each case starts with a line containing integers n and m (2 ≤ n, m ≤ 250), where n is the number of rows and m is the number of columns. The following n lines contain m characters each (0 or 1).
The total number of characters in all test cases doesn't exceed 106 for any input file.
Output
You should output exactly t lines, with the answer to the i-th test case on the i-th line.
Examples
Input
2
8 8
00010001
00101000
01000100
10000010
01000100
00101000
11010011
11000011
10 10
1111111000
1000001000
1011001000
1011001010
1000001101
1001001010
1010101000
1001001000
1000001000
1111111000
Output
1
2
Input
1
12 11
11111111111
10000000001
10111111101
10100000101
10101100101
10101100101
10100000101
10100000101
10111111101
10000000001
11111111111
00000000000
Output
3
Submitted Solution:
```
print('I have no idea...')
``` | instruction | 0 | 78,371 | 23 | 156,742 |
No | output | 1 | 78,371 | 23 | 156,743 |
Provide a correct Python 3 solution for this coding contest problem.
The Smart Beaver from ABBYY loves puzzles. One of his favorite puzzles is the magic square. He has recently had an idea to automate the solution of this puzzle. The Beaver decided to offer this challenge to the ABBYY Cup contestants.
The magic square is a matrix of size n × n. The elements of this matrix are integers. The sum of numbers in each row of the matrix is equal to some number s. The sum of numbers in each column of the matrix is also equal to s. In addition, the sum of the elements on the main diagonal is equal to s and the sum of elements on the secondary diagonal is equal to s. Examples of magic squares are given in the following figure:
<image> Magic squares
You are given a set of n2 integers ai. It is required to place these numbers into a square matrix of size n × n so that they form a magic square. Note that each number must occur in the matrix exactly the same number of times as it occurs in the original set.
It is guaranteed that a solution exists!
Input
The first input line contains a single integer n. The next line contains n2 integers ai ( - 108 ≤ ai ≤ 108), separated by single spaces.
The input limitations for getting 20 points are:
* 1 ≤ n ≤ 3
The input limitations for getting 50 points are:
* 1 ≤ n ≤ 4
* It is guaranteed that there are no more than 9 distinct numbers among ai.
The input limitations for getting 100 points are:
* 1 ≤ n ≤ 4
Output
The first line of the output should contain a single integer s. In each of the following n lines print n integers, separated by spaces and describing the resulting magic square. In the resulting magic square the sums in the rows, columns and diagonals must be equal to s. If there are multiple solutions, you are allowed to print any of them.
Examples
Input
3
1 2 3 4 5 6 7 8 9
Output
15
2 7 6
9 5 1
4 3 8
Input
3
1 0 -1 0 2 -1 -2 0 1
Output
0
1 0 -1
-2 0 2
1 0 -1
Input
2
5 5 5 5
Output
10
5 5
5 5 | instruction | 0 | 78,539 | 23 | 157,078 |
"Correct Solution:
```
import sys, random
def f(b):
global a
a = [[0] * n for o in range(n)]
for i in range(n):
for j in range(n):
a[i][j] = b[i * n + j]
rez = 0
for i in range(n):
ns = 0
for j in range(n):
ns += a[i][j]
rez += abs(su - ns)
for j in range(n):
ns = 0
for i in range(n):
ns += a[i][j]
rez += abs(su - ns)
ns = 0
for i in range(n):
ns += a[i][i]
rez += abs(su - ns)
ns = 0
for i in range(n):
ns += a[i][n - i - 1]
rez += abs(su - ns)
return rez
input = sys.stdin.readline
n = int(input())
d = list(map(int, input().split()))
su = sum(d) // n
p = f(d)
while p:
random.shuffle(d)
p = f(d)
for k in range(1000):
i = random.randint(0, n*n-1)
j = random.randint(0, n*n-1)
while i == j:
j = random.randint(0, n*n-1)
if i > j:
i, j = j, i
d[i], d[j] = d[j], d[i]
q = f(d)
if q < p:
p = q
else:
d[i], d[j] = d[j], d[i]
p = f(d)
print(su)
for i in a:
print(*i)
``` | output | 1 | 78,539 | 23 | 157,079 |
Provide a correct Python 3 solution for this coding contest problem.
The Smart Beaver from ABBYY loves puzzles. One of his favorite puzzles is the magic square. He has recently had an idea to automate the solution of this puzzle. The Beaver decided to offer this challenge to the ABBYY Cup contestants.
The magic square is a matrix of size n × n. The elements of this matrix are integers. The sum of numbers in each row of the matrix is equal to some number s. The sum of numbers in each column of the matrix is also equal to s. In addition, the sum of the elements on the main diagonal is equal to s and the sum of elements on the secondary diagonal is equal to s. Examples of magic squares are given in the following figure:
<image> Magic squares
You are given a set of n2 integers ai. It is required to place these numbers into a square matrix of size n × n so that they form a magic square. Note that each number must occur in the matrix exactly the same number of times as it occurs in the original set.
It is guaranteed that a solution exists!
Input
The first input line contains a single integer n. The next line contains n2 integers ai ( - 108 ≤ ai ≤ 108), separated by single spaces.
The input limitations for getting 20 points are:
* 1 ≤ n ≤ 3
The input limitations for getting 50 points are:
* 1 ≤ n ≤ 4
* It is guaranteed that there are no more than 9 distinct numbers among ai.
The input limitations for getting 100 points are:
* 1 ≤ n ≤ 4
Output
The first line of the output should contain a single integer s. In each of the following n lines print n integers, separated by spaces and describing the resulting magic square. In the resulting magic square the sums in the rows, columns and diagonals must be equal to s. If there are multiple solutions, you are allowed to print any of them.
Examples
Input
3
1 2 3 4 5 6 7 8 9
Output
15
2 7 6
9 5 1
4 3 8
Input
3
1 0 -1 0 2 -1 -2 0 1
Output
0
1 0 -1
-2 0 2
1 0 -1
Input
2
5 5 5 5
Output
10
5 5
5 5 | instruction | 0 | 78,540 | 23 | 157,080 |
"Correct Solution:
```
import sys, random
def f(b):
global a
a = [[0] * n for o in range(n)]
for i in range(n):
for j in range(n):
a[i][j] = b[i * n + j]
rez = 0
for i in range(n):
ns = 0
for j in range(n):
ns += a[i][j]
rez += abs(su - ns)
for j in range(n):
ns = 0
for i in range(n):
ns += a[i][j]
rez += abs(su - ns)
ns = 0
for i in range(n):
ns += a[i][i]
rez += abs(su - ns)
ns = 0
for i in range(n):
ns += a[i][n - i - 1]
rez += abs(su - ns)
return rez
# sys.stdin = open("input.txt", 'r')
input = sys.stdin.readline
n = int(input())
d = list(map(int, input().split()))
su = sum(d) // n
p = f(d)
while p:
random.shuffle(d)
p = f(d)
for k in range(1000):
i = random.randint(0, n*n-1)
j = random.randint(0, n*n-1)
while i == j:
j = random.randint(0, n*n-1)
if i > j:
i, j = j, i
d[i], d[j] = d[j], d[i]
q = f(d)
if q < p:
p = q
else:
d[i], d[j] = d[j], d[i]
p = f(d)
print(su)
for i in a:
print(*i)
``` | output | 1 | 78,540 | 23 | 157,081 |
Provide a correct Python 3 solution for this coding contest problem.
The Smart Beaver from ABBYY loves puzzles. One of his favorite puzzles is the magic square. He has recently had an idea to automate the solution of this puzzle. The Beaver decided to offer this challenge to the ABBYY Cup contestants.
The magic square is a matrix of size n × n. The elements of this matrix are integers. The sum of numbers in each row of the matrix is equal to some number s. The sum of numbers in each column of the matrix is also equal to s. In addition, the sum of the elements on the main diagonal is equal to s and the sum of elements on the secondary diagonal is equal to s. Examples of magic squares are given in the following figure:
<image> Magic squares
You are given a set of n2 integers ai. It is required to place these numbers into a square matrix of size n × n so that they form a magic square. Note that each number must occur in the matrix exactly the same number of times as it occurs in the original set.
It is guaranteed that a solution exists!
Input
The first input line contains a single integer n. The next line contains n2 integers ai ( - 108 ≤ ai ≤ 108), separated by single spaces.
The input limitations for getting 20 points are:
* 1 ≤ n ≤ 3
The input limitations for getting 50 points are:
* 1 ≤ n ≤ 4
* It is guaranteed that there are no more than 9 distinct numbers among ai.
The input limitations for getting 100 points are:
* 1 ≤ n ≤ 4
Output
The first line of the output should contain a single integer s. In each of the following n lines print n integers, separated by spaces and describing the resulting magic square. In the resulting magic square the sums in the rows, columns and diagonals must be equal to s. If there are multiple solutions, you are allowed to print any of them.
Examples
Input
3
1 2 3 4 5 6 7 8 9
Output
15
2 7 6
9 5 1
4 3 8
Input
3
1 0 -1 0 2 -1 -2 0 1
Output
0
1 0 -1
-2 0 2
1 0 -1
Input
2
5 5 5 5
Output
10
5 5
5 5 | instruction | 0 | 78,541 | 23 | 157,082 |
"Correct Solution:
```
from itertools import permutations
def check(a, n):
arr = [[0 for j in range(n)] for i in range(n)]
p = 0
for i in range(n):
for j in range(n):
arr[i][j] = a[p]
p += 1
s = sum(arr[0])
for i in range(1, n):
if s != sum(arr[i]):
return False
for i in range(n):
s1 = 0
for j in range(n):
s1 += arr[j][i]
if s1 != s:
return False
s2 = 0
for i in range(n):
s2 += arr[i][i]
if s2 != s:
return False
s2 = 0
for i in range(n):
s2 += arr[i][n-i-1]
if s2 != s:
return False
return True
n = int(input())
num = n ** 2
a = list(map(int, input().split()))
s = sum(a)//n
print(s)
for combo in permutations(a, num):
if(check(combo, n)):
for i in range(0, num, n):
print(*combo[i:i+n], sep=' ')
break
``` | output | 1 | 78,541 | 23 | 157,083 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
The Smart Beaver from ABBYY loves puzzles. One of his favorite puzzles is the magic square. He has recently had an idea to automate the solution of this puzzle. The Beaver decided to offer this challenge to the ABBYY Cup contestants.
The magic square is a matrix of size n × n. The elements of this matrix are integers. The sum of numbers in each row of the matrix is equal to some number s. The sum of numbers in each column of the matrix is also equal to s. In addition, the sum of the elements on the main diagonal is equal to s and the sum of elements on the secondary diagonal is equal to s. Examples of magic squares are given in the following figure:
<image> Magic squares
You are given a set of n2 integers ai. It is required to place these numbers into a square matrix of size n × n so that they form a magic square. Note that each number must occur in the matrix exactly the same number of times as it occurs in the original set.
It is guaranteed that a solution exists!
Input
The first input line contains a single integer n. The next line contains n2 integers ai ( - 108 ≤ ai ≤ 108), separated by single spaces.
The input limitations for getting 20 points are:
* 1 ≤ n ≤ 3
The input limitations for getting 50 points are:
* 1 ≤ n ≤ 4
* It is guaranteed that there are no more than 9 distinct numbers among ai.
The input limitations for getting 100 points are:
* 1 ≤ n ≤ 4
Output
The first line of the output should contain a single integer s. In each of the following n lines print n integers, separated by spaces and describing the resulting magic square. In the resulting magic square the sums in the rows, columns and diagonals must be equal to s. If there are multiple solutions, you are allowed to print any of them.
Examples
Input
3
1 2 3 4 5 6 7 8 9
Output
15
2 7 6
9 5 1
4 3 8
Input
3
1 0 -1 0 2 -1 -2 0 1
Output
0
1 0 -1
-2 0 2
1 0 -1
Input
2
5 5 5 5
Output
10
5 5
5 5
Submitted Solution:
```
#https://codeforces.com/problemset/problem/178/D1
def check(tab,N,suma_ogolna):
suma = 0
for i in range(N):
for j in range(N):
suma+= tab[i][j]
if suma != suma_ogolna:
return False
suma=0
suma = 0
for i in range(N):
for j in range(N):
suma+= tab[j][i]
if suma != suma_ogolna:
return False
suma=0
suma = 0
suma2 = 0
for i in range(N):
suma += tab[i][i]
suma2 += tab[i][N-i-1]
if suma != suma_ogolna:
return False
return suma_ogolna
def reku(nums,idx,tab,idx_tab,N,zajete,suma):
if idx ==len(nums):
a = check(tab,N,suma)
if a == False:
return False
return a
for i in range(N**2):
if zajete[i] ==False:
zajete[i] = True
tab[i//N][i%N] = nums[idx]
a = reku(nums,idx+1,tab,idx_tab+1,N,zajete,suma)
if a != False:
return a
zajete[i] = False
return False
def strt():
N = int(input())
nums = input().split(" ")
for i in range(len(nums)):
nums[i] = int(nums[i].strip())
suma = 0
for e in nums:
suma += e
suma //= N
print(suma)
tablica=[[0 for _ in range(N)]for _ in range(N)]
sumka=reku(nums,0,tablica,0,N,[0 for _ in range(N**2)],suma)
for i in range(N):
for j in range(N):
print(tablica[i][j],end=" ")
print()
strt()
``` | instruction | 0 | 78,542 | 23 | 157,084 |
No | output | 1 | 78,542 | 23 | 157,085 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
The Smart Beaver from ABBYY loves puzzles. One of his favorite puzzles is the magic square. He has recently had an idea to automate the solution of this puzzle. The Beaver decided to offer this challenge to the ABBYY Cup contestants.
The magic square is a matrix of size n × n. The elements of this matrix are integers. The sum of numbers in each row of the matrix is equal to some number s. The sum of numbers in each column of the matrix is also equal to s. In addition, the sum of the elements on the main diagonal is equal to s and the sum of elements on the secondary diagonal is equal to s. Examples of magic squares are given in the following figure:
<image> Magic squares
You are given a set of n2 integers ai. It is required to place these numbers into a square matrix of size n × n so that they form a magic square. Note that each number must occur in the matrix exactly the same number of times as it occurs in the original set.
It is guaranteed that a solution exists!
Input
The first input line contains a single integer n. The next line contains n2 integers ai ( - 108 ≤ ai ≤ 108), separated by single spaces.
The input limitations for getting 20 points are:
* 1 ≤ n ≤ 3
The input limitations for getting 50 points are:
* 1 ≤ n ≤ 4
* It is guaranteed that there are no more than 9 distinct numbers among ai.
The input limitations for getting 100 points are:
* 1 ≤ n ≤ 4
Output
The first line of the output should contain a single integer s. In each of the following n lines print n integers, separated by spaces and describing the resulting magic square. In the resulting magic square the sums in the rows, columns and diagonals must be equal to s. If there are multiple solutions, you are allowed to print any of them.
Examples
Input
3
1 2 3 4 5 6 7 8 9
Output
15
2 7 6
9 5 1
4 3 8
Input
3
1 0 -1 0 2 -1 -2 0 1
Output
0
1 0 -1
-2 0 2
1 0 -1
Input
2
5 5 5 5
Output
10
5 5
5 5
Submitted Solution:
```
#https://codeforces.com/problemset/problem/178/D1
def check(tab,N):
suma_ogolna = 0
for i in range(N):
suma_ogolna += tab[0][i]
suma = 0
for i in range(N):
for j in range(N):
suma+= tab[i][j]
if suma != suma_ogolna:
return False
suma=0
suma = 0
for i in range(N):
for j in range(N):
suma+= tab[j][i]
if suma != suma_ogolna:
return False
suma=0
suma = 0
for i in range(N):
suma += tab[i][i]
if suma != suma_ogolna:
return False
return suma_ogolna
def reku(nums,idx,tab,idx_tab,N,zajete):
if idx ==len(nums):
a = check(tab,N)
if a == False:
return False
return a
for i in range(N**2):
if zajete[i] ==False:
zajete[i] = True
tab[i//N][i%N] = nums[idx]
a = reku(nums,idx+1,tab,idx_tab+1,N,zajete)
if a != False:
return a
zajete[i] = False
return False
def strt():
N = int(input())
nums = input().split(" ")
for i in range(len(nums)):
nums[i] = int(nums[i].strip())
tablica=[[0 for _ in range(N)]for _ in range(N)]
sumka=reku(nums,0,tablica,0,N,[0 for _ in range(N**2)])
print(sumka)
for i in range(N):
for j in range(N):
print(tablica[i][j],end=" ")
print()
strt()
``` | instruction | 0 | 78,543 | 23 | 157,086 |
No | output | 1 | 78,543 | 23 | 157,087 |
Provide a correct Python 3 solution for this coding contest problem.
A: Hokkaido University Easy
Note
Please note that the problem settings are the same as problem B, except for the constraints.
story
Homura-chan, who passed Hokkaido University and is excited about the beginning of a new life. But in front of her, a huge campus awaits ...
"Eh ... I'm not in time for the next class ..."
problem
Hokkaido University Sapporo Campus is famous for being unusually large. The Sapporo campus is represented by rectangular squares with H squares vertically and W squares horizontally. We will use (i, j) to represent the cells that are i-mass from the north and j-mass from the west. There are several buildings on campus, with a'B'if there is a building in the location represented by the square (i, j) and a'.' If not, in c_ {i, j}.
Homura, a freshman at Hokkaido University, was surprised at the size of the campus and was worried about moving between buildings. So I was wondering how far the farthest of the two squares with the building were. Here we define the distance between two pairs of squares (i, j), (i', j') as | i-i'| + | j-j'|.
Homura found this problem difficult for him and asked his classmates for help. Please ask for an answer instead of Homura-chan.
Input format
H W
c_ {11} c_ {12} ... c_ {1W}
::
c_ {H1} c_ {H2} ... c_ {HW}
Constraint
* 2 \ leq H, W \ leq 30
* H and W are integers
* c_ {i, j} is either'B'or'.'.
* At least two of c_ {i, j} are'B'.
Output format
Print the integer that represents the answer on one line.
Input example 1
3 3
B.B
..B
.BB
Output example 1
Four
* The longest is between the two points (1,1) and (3,3).
Input example 2
4 3
B ..
B ..
...
...
Output example 2
1
* Adjacent positions may be the longest.
Input example 3
6 6
... B ..
B.B.B.
.B.B.B
... B.B
.B..B.
..B ...
Output example 3
7
Example
Input
3 3
B.B
..B
.BB
Output
4 | instruction | 0 | 79,087 | 23 | 158,174 |
"Correct Solution:
```
#!/usr/bin/python3
# -*- coding: utf-8 -*-
H,W = map(int, input().split())
builds = []
for h in range(H):
l = str(input())
for w in range(W):
if l[w] == "B":
builds.append([h,w])
ans = 0
for i,hw1 in enumerate(builds):
for hw2 in builds[i+1:]:
ans = max(ans,abs(hw1[0]-hw2[0])+abs(hw1[1]-hw2[1]))
print(ans)
``` | output | 1 | 79,087 | 23 | 158,175 |
Provide a correct Python 3 solution for this coding contest problem.
A: Hokkaido University Easy
Note
Please note that the problem settings are the same as problem B, except for the constraints.
story
Homura-chan, who passed Hokkaido University and is excited about the beginning of a new life. But in front of her, a huge campus awaits ...
"Eh ... I'm not in time for the next class ..."
problem
Hokkaido University Sapporo Campus is famous for being unusually large. The Sapporo campus is represented by rectangular squares with H squares vertically and W squares horizontally. We will use (i, j) to represent the cells that are i-mass from the north and j-mass from the west. There are several buildings on campus, with a'B'if there is a building in the location represented by the square (i, j) and a'.' If not, in c_ {i, j}.
Homura, a freshman at Hokkaido University, was surprised at the size of the campus and was worried about moving between buildings. So I was wondering how far the farthest of the two squares with the building were. Here we define the distance between two pairs of squares (i, j), (i', j') as | i-i'| + | j-j'|.
Homura found this problem difficult for him and asked his classmates for help. Please ask for an answer instead of Homura-chan.
Input format
H W
c_ {11} c_ {12} ... c_ {1W}
::
c_ {H1} c_ {H2} ... c_ {HW}
Constraint
* 2 \ leq H, W \ leq 30
* H and W are integers
* c_ {i, j} is either'B'or'.'.
* At least two of c_ {i, j} are'B'.
Output format
Print the integer that represents the answer on one line.
Input example 1
3 3
B.B
..B
.BB
Output example 1
Four
* The longest is between the two points (1,1) and (3,3).
Input example 2
4 3
B ..
B ..
...
...
Output example 2
1
* Adjacent positions may be the longest.
Input example 3
6 6
... B ..
B.B.B.
.B.B.B
... B.B
.B..B.
..B ...
Output example 3
7
Example
Input
3 3
B.B
..B
.BB
Output
4 | instruction | 0 | 79,088 | 23 | 158,176 |
"Correct Solution:
```
H, W = map(int,input().split())
s = []
for k in range(H):
s.append(input())
B = []
for k in range(H):
for l in range(W):
if s[k][l] == "B":
B.append([k,l])
ans = 0
for e in B:
for f in B:
ans = max(ans,abs(e[0]-f[0])+abs(e[1]-f[1]))
print(ans)
``` | output | 1 | 79,088 | 23 | 158,177 |
Provide a correct Python 3 solution for this coding contest problem.
A: Hokkaido University Easy
Note
Please note that the problem settings are the same as problem B, except for the constraints.
story
Homura-chan, who passed Hokkaido University and is excited about the beginning of a new life. But in front of her, a huge campus awaits ...
"Eh ... I'm not in time for the next class ..."
problem
Hokkaido University Sapporo Campus is famous for being unusually large. The Sapporo campus is represented by rectangular squares with H squares vertically and W squares horizontally. We will use (i, j) to represent the cells that are i-mass from the north and j-mass from the west. There are several buildings on campus, with a'B'if there is a building in the location represented by the square (i, j) and a'.' If not, in c_ {i, j}.
Homura, a freshman at Hokkaido University, was surprised at the size of the campus and was worried about moving between buildings. So I was wondering how far the farthest of the two squares with the building were. Here we define the distance between two pairs of squares (i, j), (i', j') as | i-i'| + | j-j'|.
Homura found this problem difficult for him and asked his classmates for help. Please ask for an answer instead of Homura-chan.
Input format
H W
c_ {11} c_ {12} ... c_ {1W}
::
c_ {H1} c_ {H2} ... c_ {HW}
Constraint
* 2 \ leq H, W \ leq 30
* H and W are integers
* c_ {i, j} is either'B'or'.'.
* At least two of c_ {i, j} are'B'.
Output format
Print the integer that represents the answer on one line.
Input example 1
3 3
B.B
..B
.BB
Output example 1
Four
* The longest is between the two points (1,1) and (3,3).
Input example 2
4 3
B ..
B ..
...
...
Output example 2
1
* Adjacent positions may be the longest.
Input example 3
6 6
... B ..
B.B.B.
.B.B.B
... B.B
.B..B.
..B ...
Output example 3
7
Example
Input
3 3
B.B
..B
.BB
Output
4 | instruction | 0 | 79,089 | 23 | 158,178 |
"Correct Solution:
```
H, W = map(int, input().split())
lst = [list(input()) for _ in range(H)]
ans = 0
for ia in range(H):
for ja in range(W):
for ib in range(H):
for jb in range(W):
if lst[ia][ja] == 'B' and lst[ib][jb] == 'B':
tmp = abs(ia-ib) + abs(ja-jb)
ans = max(ans, tmp)
print (ans)
``` | output | 1 | 79,089 | 23 | 158,179 |
Provide a correct Python 3 solution for this coding contest problem.
A: Hokkaido University Easy
Note
Please note that the problem settings are the same as problem B, except for the constraints.
story
Homura-chan, who passed Hokkaido University and is excited about the beginning of a new life. But in front of her, a huge campus awaits ...
"Eh ... I'm not in time for the next class ..."
problem
Hokkaido University Sapporo Campus is famous for being unusually large. The Sapporo campus is represented by rectangular squares with H squares vertically and W squares horizontally. We will use (i, j) to represent the cells that are i-mass from the north and j-mass from the west. There are several buildings on campus, with a'B'if there is a building in the location represented by the square (i, j) and a'.' If not, in c_ {i, j}.
Homura, a freshman at Hokkaido University, was surprised at the size of the campus and was worried about moving between buildings. So I was wondering how far the farthest of the two squares with the building were. Here we define the distance between two pairs of squares (i, j), (i', j') as | i-i'| + | j-j'|.
Homura found this problem difficult for him and asked his classmates for help. Please ask for an answer instead of Homura-chan.
Input format
H W
c_ {11} c_ {12} ... c_ {1W}
::
c_ {H1} c_ {H2} ... c_ {HW}
Constraint
* 2 \ leq H, W \ leq 30
* H and W are integers
* c_ {i, j} is either'B'or'.'.
* At least two of c_ {i, j} are'B'.
Output format
Print the integer that represents the answer on one line.
Input example 1
3 3
B.B
..B
.BB
Output example 1
Four
* The longest is between the two points (1,1) and (3,3).
Input example 2
4 3
B ..
B ..
...
...
Output example 2
1
* Adjacent positions may be the longest.
Input example 3
6 6
... B ..
B.B.B.
.B.B.B
... B.B
.B..B.
..B ...
Output example 3
7
Example
Input
3 3
B.B
..B
.BB
Output
4 | instruction | 0 | 79,090 | 23 | 158,180 |
"Correct Solution:
```
def inpl(): return list(map(int, input().split()))
H, W = inpl()
ans = 0
C = [input() for _ in range(H)]
for i in range(2):
L = [0]*H
R = [0]*H
Lk = []
Rk = []
for h in range(H):
L[h] = C[h].find("B")
R[h] = C[h].rfind("B")
if L[h] >= 0:
Lk.append(h)
if R[h] >= 0:
Rk.append(h)
for lh in Lk:
for rh in Rk:
ans = max(ans, abs(L[lh] - R[rh]) + abs(lh - rh))
if i == 0:
C = ["".join(c) for c in zip(*C)]
H, W = W, H
print(ans)
``` | output | 1 | 79,090 | 23 | 158,181 |
Provide a correct Python 3 solution for this coding contest problem.
A: Hokkaido University Easy
Note
Please note that the problem settings are the same as problem B, except for the constraints.
story
Homura-chan, who passed Hokkaido University and is excited about the beginning of a new life. But in front of her, a huge campus awaits ...
"Eh ... I'm not in time for the next class ..."
problem
Hokkaido University Sapporo Campus is famous for being unusually large. The Sapporo campus is represented by rectangular squares with H squares vertically and W squares horizontally. We will use (i, j) to represent the cells that are i-mass from the north and j-mass from the west. There are several buildings on campus, with a'B'if there is a building in the location represented by the square (i, j) and a'.' If not, in c_ {i, j}.
Homura, a freshman at Hokkaido University, was surprised at the size of the campus and was worried about moving between buildings. So I was wondering how far the farthest of the two squares with the building were. Here we define the distance between two pairs of squares (i, j), (i', j') as | i-i'| + | j-j'|.
Homura found this problem difficult for him and asked his classmates for help. Please ask for an answer instead of Homura-chan.
Input format
H W
c_ {11} c_ {12} ... c_ {1W}
::
c_ {H1} c_ {H2} ... c_ {HW}
Constraint
* 2 \ leq H, W \ leq 30
* H and W are integers
* c_ {i, j} is either'B'or'.'.
* At least two of c_ {i, j} are'B'.
Output format
Print the integer that represents the answer on one line.
Input example 1
3 3
B.B
..B
.BB
Output example 1
Four
* The longest is between the two points (1,1) and (3,3).
Input example 2
4 3
B ..
B ..
...
...
Output example 2
1
* Adjacent positions may be the longest.
Input example 3
6 6
... B ..
B.B.B.
.B.B.B
... B.B
.B..B.
..B ...
Output example 3
7
Example
Input
3 3
B.B
..B
.BB
Output
4 | instruction | 0 | 79,091 | 23 | 158,182 |
"Correct Solution:
```
# -*- coding: utf-8 -*-
import sys
from operator import itemgetter
# gcd
from fractions import gcd
# 切り上げ，切り捨て
from math import ceil, floor
# リストの真のコピー（変更が伝播しない）
from copy import deepcopy
# 累積和。list(accumulate(A))としてAの累積和
from itertools import accumulate
# l = ['a', 'b', 'b', 'c', 'b', 'a', 'c', 'c', 'b', 'c', 'b', 'a']
# S = Counter(l) # カウンタークラスが作られる。S=Counter({'b': 5, 'c': 4, 'a': 3})
# print(S.most_common(2)) # [('b', 5), ('c', 4)]
# print(S.keys()) # dict_keys(['a', 'b', 'c'])
# print(S.values()) # dict_values([3, 5, 4])
# print(S.items()) # dict_items([('a', 3), ('b', 5), ('c', 4)])
from collections import Counter
import math
from functools import reduce
sys.setrecursionlimit(200000)
# input関係の定義
# local only
# if not __debug__:
# fin = open('in_1.txt', 'r')
# sys.stdin = fin
# local only
input = sys.stdin.readline
def ii(): return int(input())
def mi(): return map(int, input().rstrip().split())
def lmi(): return list(map(int, input().rstrip().split()))
def li(): return list(input().rstrip())
def debug(*args, sep=" ", end="\n"): print("debug:", *args, file=sys.stderr, sep=sep, end=end) if not __debug__ else None
# template
H, W = mi()
S = [li() for i in range(H)]
ans = []
for i in range(H):
for j in range(W):
if S[i][j] == "B":
ans.append((i, j))
ans.sort(key=lambda x: x[0] + x[1])
debug(ans[-1])
debug(ans[0])
tmp = abs(ans[-1][0] - ans[0][0]) + abs(ans[-1][1] - ans[0][1])
ans.sort(key=lambda x: x[0] + (W - x[1]))
debug(ans[-1])
debug(ans[0])
tmp2 = abs(ans[-1][0] - ans[0][0]) + abs(ans[-1][1] - ans[0][1])
print(max(tmp,tmp2))
``` | output | 1 | 79,091 | 23 | 158,183 |
Provide a correct Python 3 solution for this coding contest problem.
A: Hokkaido University Easy
Note
Please note that the problem settings are the same as problem B, except for the constraints.
story
Homura-chan, who passed Hokkaido University and is excited about the beginning of a new life. But in front of her, a huge campus awaits ...
"Eh ... I'm not in time for the next class ..."
problem
Hokkaido University Sapporo Campus is famous for being unusually large. The Sapporo campus is represented by rectangular squares with H squares vertically and W squares horizontally. We will use (i, j) to represent the cells that are i-mass from the north and j-mass from the west. There are several buildings on campus, with a'B'if there is a building in the location represented by the square (i, j) and a'.' If not, in c_ {i, j}.
Homura, a freshman at Hokkaido University, was surprised at the size of the campus and was worried about moving between buildings. So I was wondering how far the farthest of the two squares with the building were. Here we define the distance between two pairs of squares (i, j), (i', j') as | i-i'| + | j-j'|.
Homura found this problem difficult for him and asked his classmates for help. Please ask for an answer instead of Homura-chan.
Input format
H W
c_ {11} c_ {12} ... c_ {1W}
::
c_ {H1} c_ {H2} ... c_ {HW}
Constraint
* 2 \ leq H, W \ leq 30
* H and W are integers
* c_ {i, j} is either'B'or'.'.
* At least two of c_ {i, j} are'B'.
Output format
Print the integer that represents the answer on one line.
Input example 1
3 3
B.B
..B
.BB
Output example 1
Four
* The longest is between the two points (1,1) and (3,3).
Input example 2
4 3
B ..
B ..
...
...
Output example 2
1
* Adjacent positions may be the longest.
Input example 3
6 6
... B ..
B.B.B.
.B.B.B
... B.B
.B..B.
..B ...
Output example 3
7
Example
Input
3 3
B.B
..B
.BB
Output
4 | instruction | 0 | 79,092 | 23 | 158,184 |
"Correct Solution:
```
H,W=map(int,input().split())
MAP=[list(input()) for i in range(H)]
BLIST=[]
for i in range(H):
for j in range(W):
if MAP[i][j]=="B":
BLIST.append([i,j])
BLIST.sort(key=lambda x:x[0]+x[1])
ANS=abs(BLIST[0][0]-BLIST[-1][0])+abs(BLIST[0][1]-BLIST[-1][1])
BLIST.sort(key=lambda x:x[0]-x[1])
ANS=max(ANS,abs(BLIST[0][0]-BLIST[-1][0])+abs(BLIST[0][1]-BLIST[-1][1]))
print(ANS)
``` | output | 1 | 79,092 | 23 | 158,185 |
Provide a correct Python 3 solution for this coding contest problem.
A: Hokkaido University Easy
Note
Please note that the problem settings are the same as problem B, except for the constraints.
story
Homura-chan, who passed Hokkaido University and is excited about the beginning of a new life. But in front of her, a huge campus awaits ...
"Eh ... I'm not in time for the next class ..."
problem
Hokkaido University Sapporo Campus is famous for being unusually large. The Sapporo campus is represented by rectangular squares with H squares vertically and W squares horizontally. We will use (i, j) to represent the cells that are i-mass from the north and j-mass from the west. There are several buildings on campus, with a'B'if there is a building in the location represented by the square (i, j) and a'.' If not, in c_ {i, j}.
Homura, a freshman at Hokkaido University, was surprised at the size of the campus and was worried about moving between buildings. So I was wondering how far the farthest of the two squares with the building were. Here we define the distance between two pairs of squares (i, j), (i', j') as | i-i'| + | j-j'|.
Homura found this problem difficult for him and asked his classmates for help. Please ask for an answer instead of Homura-chan.
Input format
H W
c_ {11} c_ {12} ... c_ {1W}
::
c_ {H1} c_ {H2} ... c_ {HW}
Constraint
* 2 \ leq H, W \ leq 30
* H and W are integers
* c_ {i, j} is either'B'or'.'.
* At least two of c_ {i, j} are'B'.
Output format
Print the integer that represents the answer on one line.
Input example 1
3 3
B.B
..B
.BB
Output example 1
Four
* The longest is between the two points (1,1) and (3,3).
Input example 2
4 3
B ..
B ..
...
...
Output example 2
1
* Adjacent positions may be the longest.
Input example 3
6 6
... B ..
B.B.B.
.B.B.B
... B.B
.B..B.
..B ...
Output example 3
7
Example
Input
3 3
B.B
..B
.BB
Output
4 | instruction | 0 | 79,093 | 23 | 158,186 |
"Correct Solution:
```
# from sys import exit
H, W = [int(n) for n in input().split()]
c = [[0 for _ in range(W)] for __ in range(H)]
Bs = []
for i in range(H):
c[i] = list(str(input()))
for j in range(W):
if c[i][j] == "B":
Bs.append((i, j))
ans = 0
for e0 in Bs:
for e1 in Bs:
ans = max(ans, abs(e0[0] - e1[0]) + abs(e0[1] - e1[1]))
print(ans)
``` | output | 1 | 79,093 | 23 | 158,187 |
Provide tags and a correct Python 3 solution for this coding contest problem.
Little Petya very much likes rectangles and especially squares. Recently he has received 8 points on the plane as a gift from his mother. The points are pairwise distinct. Petya decided to split them into two sets each containing 4 points so that the points from the first set lay at the vertexes of some square and the points from the second set lay at the vertexes of a rectangle. Each point of initial 8 should belong to exactly one set. It is acceptable for a rectangle from the second set was also a square. If there are several partitions, Petya will be satisfied by any of them. Help him find such partition. Note that the rectangle and the square from the partition should have non-zero areas. The sides of the figures do not have to be parallel to the coordinate axes, though it might be the case.
Input
You are given 8 pairs of integers, a pair per line — the coordinates of the points Petya has. The absolute value of all coordinates does not exceed 104. It is guaranteed that no two points coincide.
Output
Print in the first output line "YES" (without the quotes), if the desired partition exists. In the second line output 4 space-separated numbers — point indexes from the input, which lie at the vertexes of the square. The points are numbered starting from 1. The numbers can be printed in any order. In the third line print the indexes of points lying at the vertexes of a rectangle in the similar format. All printed numbers should be pairwise distinct.
If the required partition does not exist, the first line should contain the word "NO" (without the quotes), after which no output is needed.
Examples
Input
0 0
10 11
10 0
0 11
1 1
2 2
2 1
1 2
Output
YES
5 6 7 8
1 2 3 4
Input
0 0
1 1
2 2
3 3
4 4
5 5
6 6
7 7
Output
NO
Input
0 0
4 4
4 0
0 4
1 2
2 3
3 2
2 1
Output
YES
1 2 3 4
5 6 7 8
Note
Pay attention to the third example: the figures do not necessarily have to be parallel to the coordinate axes. | instruction | 0 | 79,310 | 23 | 158,620 |
Tags: brute force, geometry, math
Correct Solution:
```
from sys import stdin, stdout
from itertools import permutations as p
from itertools import combinations as com
def sqr_or_rec(a, b, c, d):
x = ((a[1] - b[1])**2 + (a[0] - b[0]) **2)
y = ((c[1] - b[1])**2 + (c[0] - b[0]) **2)
w = ((c[1] - d[1])**2 + (c[0] - d[0]) **2)
z = ((a[1] - d[1])**2 + (a[0] - d[0]) **2)
hypo1 = ((a[1] - c[1])**2 + (a[0] - c[0]) **2)
hypo2 = ((b[1] - d[1])**2 + (b[0] - d[0]) **2)
if len(set([x,y,w,z])) == 1 and hypo1 == x + y and hypo2 == hypo1 and hypo2 == w + z:
return 0
elif len(set([x,y,w,z])) == 2 and hypo1 == x + y and hypo2 == hypo1 and hypo2 == w + z:
return 1
else:
return -1
x = []
for i in range(8):
l, m = map(int, input().split())
x.append([l, m])
sqr, rec = [], []
for g in p(list(range(8)), 4):
a, b, c, d = x[g[0]], x[g[1]], x[g[2]], x[g[3]]
if sqr_or_rec(a,b,c,d) == 0:
y = sorted(g)
if y not in sqr:
sqr.append(y)
elif sqr_or_rec(a,b,c,d) == 1:
y = sorted(g)
if y not in rec:
rec.append(y)
if len(sqr) == 0 or (len(sqr) == 1 and len(rec) == 0):
print("NO")
else:
if len(sqr) >= 2:
for q in com(sqr, 2):
if len(set(q[0] + q[1])) == 8:
print("YES")
for k in sqr[0]:
stdout.write(str(k+1)+" ")
print()
for k in sqr[1]:
stdout.write(str(k+1)+" ")
print()
exit()
for q in rec:
if len(set(q + sqr[0])) == 8:
print("YES")
for k in sqr[0]:
stdout.write(str(k+1)+" ")
print()
for k in q:
stdout.write(str(k+1)+" ")
print()
exit()
print("NO")
# Made By Mostafa_Khaled
``` | output | 1 | 79,310 | 23 | 158,621 |
Provide tags and a correct Python 3 solution for this coding contest problem.
Little Petya very much likes rectangles and especially squares. Recently he has received 8 points on the plane as a gift from his mother. The points are pairwise distinct. Petya decided to split them into two sets each containing 4 points so that the points from the first set lay at the vertexes of some square and the points from the second set lay at the vertexes of a rectangle. Each point of initial 8 should belong to exactly one set. It is acceptable for a rectangle from the second set was also a square. If there are several partitions, Petya will be satisfied by any of them. Help him find such partition. Note that the rectangle and the square from the partition should have non-zero areas. The sides of the figures do not have to be parallel to the coordinate axes, though it might be the case.
Input
You are given 8 pairs of integers, a pair per line — the coordinates of the points Petya has. The absolute value of all coordinates does not exceed 104. It is guaranteed that no two points coincide.
Output
Print in the first output line "YES" (without the quotes), if the desired partition exists. In the second line output 4 space-separated numbers — point indexes from the input, which lie at the vertexes of the square. The points are numbered starting from 1. The numbers can be printed in any order. In the third line print the indexes of points lying at the vertexes of a rectangle in the similar format. All printed numbers should be pairwise distinct.
If the required partition does not exist, the first line should contain the word "NO" (without the quotes), after which no output is needed.
Examples
Input
0 0
10 11
10 0
0 11
1 1
2 2
2 1
1 2
Output
YES
5 6 7 8
1 2 3 4
Input
0 0
1 1
2 2
3 3
4 4
5 5
6 6
7 7
Output
NO
Input
0 0
4 4
4 0
0 4
1 2
2 3
3 2
2 1
Output
YES
1 2 3 4
5 6 7 8
Note
Pay attention to the third example: the figures do not necessarily have to be parallel to the coordinate axes. | instruction | 0 | 79,311 | 23 | 158,622 |
Tags: brute force, geometry, math
Correct Solution:
```
from itertools import combinations, permutations
from math import sqrt
EPS = 1e-6
def sd(x, y):
return ((x[0] - y[0])**2 + (x[1] - y[1])**2)
def is_square(points):
for perm in permutations(points):
if sd(perm[0], perm[1]) == sd(perm[1], perm[2]) == \
sd(perm[2], perm[3]) == sd(perm[3], perm[0]) and \
sd(perm[0], perm[2]) == 2 * sd(perm[0], perm[1]) and \
sd(perm[1], perm[3]) == 2 * sd(perm[0], perm[1]) and \
sqrt(sd(perm[0], perm[1])) * sqrt(sd(perm[1], perm[2])) > EPS:
return True
return False
def is_rect(points):
for perm in permutations(points):
if sd(perm[0], perm[1]) == sd(perm[2], perm[3]) and \
sd(perm[1], perm[2]) == sd(perm[3], perm[0]) and \
sd(perm[0], perm[2]) == sd(perm[0], perm[1]) + sd(perm[1], perm[2]) and \
sd(perm[1], perm[3]) == sd(perm[1], perm[2]) + sd(perm[2], perm[3]) and \
sqrt(sd(perm[0], perm[1])) * sqrt(sd(perm[1], perm[2])) > EPS:
return True
return False
AMOUNT = 8
points = []
for _ in range(AMOUNT):
points += [list(map(int, input().split()))]
found = False
to_choose = list(range(AMOUNT))
for for_square in combinations(to_choose, r=4):
square, rect = [], []
for i in range(AMOUNT):
if i in for_square:
square += [points[i]]
else:
rect += [points[i]]
if is_square(square) and is_rect(rect):
print("YES")
print(' '.join(map(lambda x: str(x + 1), for_square)))
print(' '.join(map(lambda x: str(x + 1), [y for y in range(AMOUNT) if y not in for_square])))
found = True
break
if not found:
print("NO")
``` | output | 1 | 79,311 | 23 | 158,623 |
Provide tags and a correct Python 3 solution for this coding contest problem.
Little Petya very much likes rectangles and especially squares. Recently he has received 8 points on the plane as a gift from his mother. The points are pairwise distinct. Petya decided to split them into two sets each containing 4 points so that the points from the first set lay at the vertexes of some square and the points from the second set lay at the vertexes of a rectangle. Each point of initial 8 should belong to exactly one set. It is acceptable for a rectangle from the second set was also a square. If there are several partitions, Petya will be satisfied by any of them. Help him find such partition. Note that the rectangle and the square from the partition should have non-zero areas. The sides of the figures do not have to be parallel to the coordinate axes, though it might be the case.
Input
You are given 8 pairs of integers, a pair per line — the coordinates of the points Petya has. The absolute value of all coordinates does not exceed 104. It is guaranteed that no two points coincide.
Output
Print in the first output line "YES" (without the quotes), if the desired partition exists. In the second line output 4 space-separated numbers — point indexes from the input, which lie at the vertexes of the square. The points are numbered starting from 1. The numbers can be printed in any order. In the third line print the indexes of points lying at the vertexes of a rectangle in the similar format. All printed numbers should be pairwise distinct.
If the required partition does not exist, the first line should contain the word "NO" (without the quotes), after which no output is needed.
Examples
Input
0 0
10 11
10 0
0 11
1 1
2 2
2 1
1 2
Output
YES
5 6 7 8
1 2 3 4
Input
0 0
1 1
2 2
3 3
4 4
5 5
6 6
7 7
Output
NO
Input
0 0
4 4
4 0
0 4
1 2
2 3
3 2
2 1
Output
YES
1 2 3 4
5 6 7 8
Note
Pay attention to the third example: the figures do not necessarily have to be parallel to the coordinate axes. | instruction | 0 | 79,312 | 23 | 158,624 |
Tags: brute force, geometry, math
Correct Solution:
```
from sys import stdin, stdout
from itertools import permutations as p
from itertools import combinations as com
def sqr_or_rec(a, b, c, d):
x = ((a[1] - b[1])**2 + (a[0] - b[0]) **2)
y = ((c[1] - b[1])**2 + (c[0] - b[0]) **2)
w = ((c[1] - d[1])**2 + (c[0] - d[0]) **2)
z = ((a[1] - d[1])**2 + (a[0] - d[0]) **2)
hypo1 = ((a[1] - c[1])**2 + (a[0] - c[0]) **2)
hypo2 = ((b[1] - d[1])**2 + (b[0] - d[0]) **2)
if len(set([x,y,w,z])) == 1 and hypo1 == x + y and hypo2 == hypo1 and hypo2 == w + z:
return 0
elif len(set([x,y,w,z])) == 2 and hypo1 == x + y and hypo2 == hypo1 and hypo2 == w + z:
return 1
else:
return -1
x = []
for i in range(8):
l, m = map(int, input().split())
x.append([l, m])
sqr, rec = [], []
for g in p(list(range(8)), 4):
a, b, c, d = x[g[0]], x[g[1]], x[g[2]], x[g[3]]
if sqr_or_rec(a,b,c,d) == 0:
y = sorted(g)
if y not in sqr:
sqr.append(y)
elif sqr_or_rec(a,b,c,d) == 1:
y = sorted(g)
if y not in rec:
rec.append(y)
if len(sqr) == 0 or (len(sqr) == 1 and len(rec) == 0):
print("NO")
else:
if len(sqr) >= 2:
for q in com(sqr, 2):
if len(set(q[0] + q[1])) == 8:
print("YES")
for k in sqr[0]:
stdout.write(str(k+1)+" ")
print()
for k in sqr[1]:
stdout.write(str(k+1)+" ")
print()
exit()
for q in rec:
if len(set(q + sqr[0])) == 8:
print("YES")
for k in sqr[0]:
stdout.write(str(k+1)+" ")
print()
for k in q:
stdout.write(str(k+1)+" ")
print()
exit()
print("NO")
``` | output | 1 | 79,312 | 23 | 158,625 |
Provide tags and a correct Python 3 solution for this coding contest problem.
Little Petya very much likes rectangles and especially squares. Recently he has received 8 points on the plane as a gift from his mother. The points are pairwise distinct. Petya decided to split them into two sets each containing 4 points so that the points from the first set lay at the vertexes of some square and the points from the second set lay at the vertexes of a rectangle. Each point of initial 8 should belong to exactly one set. It is acceptable for a rectangle from the second set was also a square. If there are several partitions, Petya will be satisfied by any of them. Help him find such partition. Note that the rectangle and the square from the partition should have non-zero areas. The sides of the figures do not have to be parallel to the coordinate axes, though it might be the case.
Input
You are given 8 pairs of integers, a pair per line — the coordinates of the points Petya has. The absolute value of all coordinates does not exceed 104. It is guaranteed that no two points coincide.
Output
Print in the first output line "YES" (without the quotes), if the desired partition exists. In the second line output 4 space-separated numbers — point indexes from the input, which lie at the vertexes of the square. The points are numbered starting from 1. The numbers can be printed in any order. In the third line print the indexes of points lying at the vertexes of a rectangle in the similar format. All printed numbers should be pairwise distinct.
If the required partition does not exist, the first line should contain the word "NO" (without the quotes), after which no output is needed.
Examples
Input
0 0
10 11
10 0
0 11
1 1
2 2
2 1
1 2
Output
YES
5 6 7 8
1 2 3 4
Input
0 0
1 1
2 2
3 3
4 4
5 5
6 6
7 7
Output
NO
Input
0 0
4 4
4 0
0 4
1 2
2 3
3 2
2 1
Output
YES
1 2 3 4
5 6 7 8
Note
Pay attention to the third example: the figures do not necessarily have to be parallel to the coordinate axes. | instruction | 0 | 79,313 | 23 | 158,626 |
Tags: brute force, geometry, math
Correct Solution:
```
import itertools
import math
import os
import sys
eps = 1e-8
coord = [[]] + [list(map(int, input().split())) for _ in range(8)]
idx = list(range(1, 9))
def perpendicular(v1, v2):
return sum([x * y for (x, y) in zip(v1, v2)]) < eps
def all_perpendicular(vs):
return all([perpendicular(vs[i], vs[(i+1)%4]) for i in range(4)])
def rect_sides(vs):
ls = list(map(lambda v: math.hypot(*v), vs))
return abs(ls[0] - ls[2]) < eps and abs(ls[1] - ls[3]) < eps
def square_sides(vs):
ls = list(map(lambda v: math.hypot(*v), vs))
l = ls[0]
for lx in ls:
if abs(lx - l) > eps:
return False
return True
def coords_to_vecs(cs):
return [
[cs[(i+1)%4][0] - cs[i][0], cs[(i+1)%4][1] - cs[i][1]]
for i in range(4)]
def is_square(coords):
for p in itertools.permutations(coords):
vs = coords_to_vecs(p)
if all_perpendicular(vs) and square_sides(vs):
return True
return False
def is_rect(coord):
for p in itertools.permutations(coord):
vs = coords_to_vecs(p)
if all_perpendicular(vs) and rect_sides(vs):
return True
return False
for comb in itertools.combinations(idx, 4):
fsi = list(comb)
ssi = list(set(idx) - set(comb))
fs = [coord[i] for i in fsi]
ss = [coord[i] for i in ssi]
if is_square(fs) and is_rect(ss):
print("YES")
print(' '.join(map(str, fsi)))
print(' '.join(map(str, ssi)))
sys.exit(0)
if is_square(ss) and is_rect(fs):
print("YES")
print(' '.join(map(str, ssi)))
print(' '.join(map(str, fsi)))
sys.exit(0)
print("NO")
``` | output | 1 | 79,313 | 23 | 158,627 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
Little Petya very much likes rectangles and especially squares. Recently he has received 8 points on the plane as a gift from his mother. The points are pairwise distinct. Petya decided to split them into two sets each containing 4 points so that the points from the first set lay at the vertexes of some square and the points from the second set lay at the vertexes of a rectangle. Each point of initial 8 should belong to exactly one set. It is acceptable for a rectangle from the second set was also a square. If there are several partitions, Petya will be satisfied by any of them. Help him find such partition. Note that the rectangle and the square from the partition should have non-zero areas. The sides of the figures do not have to be parallel to the coordinate axes, though it might be the case.
Input
You are given 8 pairs of integers, a pair per line — the coordinates of the points Petya has. The absolute value of all coordinates does not exceed 104. It is guaranteed that no two points coincide.
Output
Print in the first output line "YES" (without the quotes), if the desired partition exists. In the second line output 4 space-separated numbers — point indexes from the input, which lie at the vertexes of the square. The points are numbered starting from 1. The numbers can be printed in any order. In the third line print the indexes of points lying at the vertexes of a rectangle in the similar format. All printed numbers should be pairwise distinct.
If the required partition does not exist, the first line should contain the word "NO" (without the quotes), after which no output is needed.
Examples
Input
0 0
10 11
10 0
0 11
1 1
2 2
2 1
1 2
Output
YES
5 6 7 8
1 2 3 4
Input
0 0
1 1
2 2
3 3
4 4
5 5
6 6
7 7
Output
NO
Input
0 0
4 4
4 0
0 4
1 2
2 3
3 2
2 1
Output
YES
1 2 3 4
5 6 7 8
Note
Pay attention to the third example: the figures do not necessarily have to be parallel to the coordinate axes.
Submitted Solution:
```
from itertools import combinations, permutations
from math import sqrt
EPS = 1e-6
def sd(x, y):
return ((x[0] - y[0])**2 + (x[1] - y[1])**2)
def is_square(points):
for perm in permutations(points):
if sd(perm[0], perm[1]) == sd(perm[1], perm[2]) == \
sd(perm[2], perm[3]) == sd(perm[3], perm[0]) and \
sd(perm[0], perm[2]) == 2 * sd(perm[0], perm[1]) and \
sd(perm[1], perm[3]) == 2 * sd(perm[0], perm[1]) and \
sqrt(sd(perm[0], perm[1])) * sqrt(sd(perm[1], perm[2])) > EPS:
return True
return False
def is_rect(point):
for perm in permutations(points):
if sd(perm[0], perm[1]) == sd(perm[2], perm[3]) and \
sd(perm[1], perm[2]) == sd(perm[3], perm[0]) and \
sd(perm[0], perm[2]) == sd(perm[0], perm[1]) + sd(perm[1], perm[2]) and \
sd(perm[1], perm[3]) == sd(perm[1], perm[2]) + sd(perm[2], perm[3]) and \
sqrt(sd(perm[0], perm[1])) * sqrt(sd(perm[1], perm[2])) > EPS:
return True
return False
AMOUNT = 8
points = []
for _ in range(AMOUNT):
points += [list(map(int, input().split()))]
found = False
to_choose = list(range(AMOUNT))
for for_square in combinations(to_choose, r=4):
square, rect = [], []
for i in range(AMOUNT):
if i in for_square:
square += [points[i]]
else:
rect += [points[i]]
if is_square(square) and is_rect(rect):
print("YES")
print(' '.join(map(lambda x: str(x + 1), for_square)))
print(' '.join(map(lambda x: str(x + 1), [y for y in range(AMOUNT) if y not in for_square])))
found = True
break
if not found:
print("NO")
``` | instruction | 0 | 79,314 | 23 | 158,628 |
No | output | 1 | 79,314 | 23 | 158,629 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
Little Petya very much likes rectangles and especially squares. Recently he has received 8 points on the plane as a gift from his mother. The points are pairwise distinct. Petya decided to split them into two sets each containing 4 points so that the points from the first set lay at the vertexes of some square and the points from the second set lay at the vertexes of a rectangle. Each point of initial 8 should belong to exactly one set. It is acceptable for a rectangle from the second set was also a square. If there are several partitions, Petya will be satisfied by any of them. Help him find such partition. Note that the rectangle and the square from the partition should have non-zero areas. The sides of the figures do not have to be parallel to the coordinate axes, though it might be the case.
Input
You are given 8 pairs of integers, a pair per line — the coordinates of the points Petya has. The absolute value of all coordinates does not exceed 104. It is guaranteed that no two points coincide.
Output
Print in the first output line "YES" (without the quotes), if the desired partition exists. In the second line output 4 space-separated numbers — point indexes from the input, which lie at the vertexes of the square. The points are numbered starting from 1. The numbers can be printed in any order. In the third line print the indexes of points lying at the vertexes of a rectangle in the similar format. All printed numbers should be pairwise distinct.
If the required partition does not exist, the first line should contain the word "NO" (without the quotes), after which no output is needed.
Examples
Input
0 0
10 11
10 0
0 11
1 1
2 2
2 1
1 2
Output
YES
5 6 7 8
1 2 3 4
Input
0 0
1 1
2 2
3 3
4 4
5 5
6 6
7 7
Output
NO
Input
0 0
4 4
4 0
0 4
1 2
2 3
3 2
2 1
Output
YES
1 2 3 4
5 6 7 8
Note
Pay attention to the third example: the figures do not necessarily have to be parallel to the coordinate axes.
Submitted Solution:
```
import itertools
import math
import os
import sys
eps = 1e-8
coord = [[]] + [list(map(int, input().split())) for _ in range(8)]
idx = list(range(1, 9))
def perpendicular(v1, v2):
return sum([x * y for (x, y) in zip(v1, v2)]) < eps
def all_perpendicular(vs):
return all([perpendicular(vs[i], vs[(i+1)%4]) for i in range(4)])
def rect_sides(vs):
ls = list(map(lambda v: math.hypot(*v), vs))
return abs(ls[0] - ls[2]) < eps and abs(ls[1] - ls[3]) < eps
def square_sides(vs):
ls = list(map(lambda v: math.hypot(*v), vs))
l = ls[0]
for lx in ls:
if abs(lx - l) > eps:
return False
return True
def coords_to_vecs(cs):
return [
[cs[(i+1)%4][0] - cs[i][0], cs[(i+1)%4][1] - cs[i][1]]
for i in range(4)]
def is_square(coords):
for p in itertools.permutations(coords):
vs = coords_to_vecs(p)
if all_perpendicular(vs) and square_sides(vs):
return True
return False
def is_rect(coord):
for p in itertools.permutations(coord):
vs = coords_to_vecs(p)
if all_perpendicular(vs) and rect_sides(vs):
return True
return False
for comb in itertools.combinations(idx, 4):
fsi = list(comb)
ssi = list(set(idx) - set(comb))
fs = [coord[i] for i in fsi]
ss = [coord[i] for i in ssi]
if is_square(fs) and is_rect(ss):
print(' '.join(map(str, fsi)))
print(' '.join(map(str, ssi)))
sys.exit(0)
if is_square(ss) and is_rect(fs):
print(' '.join(map(str, ssi)))
print(' '.join(map(str, fsi)))
sys.exit(0)
print("NO")
``` | instruction | 0 | 79,315 | 23 | 158,630 |
No | output | 1 | 79,315 | 23 | 158,631 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
Little Petya very much likes rectangles and especially squares. Recently he has received 8 points on the plane as a gift from his mother. The points are pairwise distinct. Petya decided to split them into two sets each containing 4 points so that the points from the first set lay at the vertexes of some square and the points from the second set lay at the vertexes of a rectangle. Each point of initial 8 should belong to exactly one set. It is acceptable for a rectangle from the second set was also a square. If there are several partitions, Petya will be satisfied by any of them. Help him find such partition. Note that the rectangle and the square from the partition should have non-zero areas. The sides of the figures do not have to be parallel to the coordinate axes, though it might be the case.
Input
You are given 8 pairs of integers, a pair per line — the coordinates of the points Petya has. The absolute value of all coordinates does not exceed 104. It is guaranteed that no two points coincide.
Output
Print in the first output line "YES" (without the quotes), if the desired partition exists. In the second line output 4 space-separated numbers — point indexes from the input, which lie at the vertexes of the square. The points are numbered starting from 1. The numbers can be printed in any order. In the third line print the indexes of points lying at the vertexes of a rectangle in the similar format. All printed numbers should be pairwise distinct.
If the required partition does not exist, the first line should contain the word "NO" (without the quotes), after which no output is needed.
Examples
Input
0 0
10 11
10 0
0 11
1 1
2 2
2 1
1 2
Output
YES
5 6 7 8
1 2 3 4
Input
0 0
1 1
2 2
3 3
4 4
5 5
6 6
7 7
Output
NO
Input
0 0
4 4
4 0
0 4
1 2
2 3
3 2
2 1
Output
YES
1 2 3 4
5 6 7 8
Note
Pay attention to the third example: the figures do not necessarily have to be parallel to the coordinate axes.
Submitted Solution:
```
from sys import stdin, stdout
from itertools import permutations as p
from itertools import combinations as com
def sqr_or_rec(a, b, c, d):
x = ((a[1] - b[1])**2 + (a[0] - b[0]) **2)
y = ((c[1] - b[1])**2 + (c[0] - b[0]) **2)
w = ((c[1] - d[1])**2 + (c[0] - d[0]) **2)
z = ((a[1] - d[1])**2 + (a[0] - d[0]) **2)
if len(set([x,y,w,z])) == 1:
return 0
elif len(set([x,y,w,z])) == 2:
return 1
else:
return -1
x = []
for i in range(8):
l, m = map(int, input().split())
x.append([l, m])
sqr, rec = [], []
for g in p(list(range(8)), 4):
a, b, c, d = x[g[0]], x[g[1]], x[g[2]], x[g[3]]
if sqr_or_rec(a,b,c,d) == 0:
y = sorted(g)
if y not in sqr:
sqr.append(y)
elif sqr_or_rec(a,b,c,d) == 1:
y = sorted(g)
if y not in rec:
rec.append(y)
if len(sqr) == 0 or (len(sqr) == 1 and len(rec) == 0):
print("NO")
else:
if len(sqr) >= 2:
for q in com(sqr, 2):
if len(set(q[0] + q[1])) == 8:
print("YES")
for k in sqr[0]:
stdout.write(str(k+1)+" ")
print()
for k in sqr[1]:
stdout.write(str(k+1)+" ")
print()
exit()
else:
for q in rec:
if len(set(q + sqr[0])) == 8:
print("YES")
for k in sqr[0]:
stdout.write(str(k+1)+" ")
print()
for k in q:
stdout.write(str(k+1)+" ")
print()
exit()
print("NO")
``` | instruction | 0 | 79,316 | 23 | 158,632 |
No | output | 1 | 79,316 | 23 | 158,633 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
Little Petya very much likes rectangles and especially squares. Recently he has received 8 points on the plane as a gift from his mother. The points are pairwise distinct. Petya decided to split them into two sets each containing 4 points so that the points from the first set lay at the vertexes of some square and the points from the second set lay at the vertexes of a rectangle. Each point of initial 8 should belong to exactly one set. It is acceptable for a rectangle from the second set was also a square. If there are several partitions, Petya will be satisfied by any of them. Help him find such partition. Note that the rectangle and the square from the partition should have non-zero areas. The sides of the figures do not have to be parallel to the coordinate axes, though it might be the case.
Input
You are given 8 pairs of integers, a pair per line — the coordinates of the points Petya has. The absolute value of all coordinates does not exceed 104. It is guaranteed that no two points coincide.
Output
Print in the first output line "YES" (without the quotes), if the desired partition exists. In the second line output 4 space-separated numbers — point indexes from the input, which lie at the vertexes of the square. The points are numbered starting from 1. The numbers can be printed in any order. In the third line print the indexes of points lying at the vertexes of a rectangle in the similar format. All printed numbers should be pairwise distinct.
If the required partition does not exist, the first line should contain the word "NO" (without the quotes), after which no output is needed.
Examples
Input
0 0
10 11
10 0
0 11
1 1
2 2
2 1
1 2
Output
YES
5 6 7 8
1 2 3 4
Input
0 0
1 1
2 2
3 3
4 4
5 5
6 6
7 7
Output
NO
Input
0 0
4 4
4 0
0 4
1 2
2 3
3 2
2 1
Output
YES
1 2 3 4
5 6 7 8
Note
Pay attention to the third example: the figures do not necessarily have to be parallel to the coordinate axes.
Submitted Solution:
```
from sys import stdin, stdout
from itertools import permutations as p
from itertools import combinations as com
def sqr_or_rec(a, b, c, d):
x = ((a[1] - b[1])**2 + (a[0] - b[0]) **2)
y = ((c[1] - b[1])**2 + (c[0] - b[0]) **2)
w = ((c[1] - d[1])**2 + (c[0] - d[0]) **2)
z = ((a[1] - d[1])**2 + (a[0] - d[0]) **2)
if len(set([a[0],b[0],c[0],d[0]])) == 2 or len(set([a[0],b[0],c[0],d[0]])) == 3:
if len(set([x,y,w,z])) == 1:
return 0
elif len(set([x,y,w,z])) == 2:
return 1
else:
return -1
else:
return -1
x = []
for i in range(8):
l, m = map(int, input().split())
x.append([l, m])
sqr, rec = [], []
for g in p(list(range(8)), 4):
a, b, c, d = x[g[0]], x[g[1]], x[g[2]], x[g[3]]
if sqr_or_rec(a,b,c,d) == 0:
y = sorted(g)
if y not in sqr:
sqr.append(y)
elif sqr_or_rec(a,b,c,d) == 1:
y = sorted(g)
if y not in rec:
rec.append(y)
if len(sqr) == 0 or (len(sqr) == 1 and len(rec) == 0):
print("NO")
else:
if len(sqr) >= 2:
for q in com(sqr, 2):
if len(set(q[0] + q[1])) == 8:
print("YES")
for k in sqr[0]:
stdout.write(str(k+1)+" ")
print()
for k in sqr[1]:
stdout.write(str(k+1)+" ")
print()
exit()
else:
for q in rec:
if len(set(q + sqr[0])) == 8:
print("YES")
for k in sqr[0]:
stdout.write(str(k+1)+" ")
print()
for k in q:
stdout.write(str(k+1)+" ")
print()
exit()
print("NO")
``` | instruction | 0 | 79,317 | 23 | 158,634 |
No | output | 1 | 79,317 | 23 | 158,635 |
Provide tags and a correct Python 3 solution for this coding contest problem.
Convexity of a set of points on the plane is the size of the largest subset of points that form a convex polygon. Your task is to build a set of n points with the convexity of exactly m. Your set of points should not contain three points that lie on a straight line.
Input
The single line contains two integers n and m (3 ≤ m ≤ 100, m ≤ n ≤ 2m).
Output
If there is no solution, print "-1". Otherwise, print n pairs of integers — the coordinates of points of any set with the convexity of m. The coordinates shouldn't exceed 108 in their absolute value.
Examples
Input
4 3
Output
0 0
3 0
0 3
1 1
Input
6 3
Output
-1
Input
6 6
Output
10 0
-10 0
10 1
9 1
9 -1
0 -2
Input
7 4
Output
176166 6377
709276 539564
654734 174109
910147 434207
790497 366519
606663 21061
859328 886001 | instruction | 0 | 79,416 | 23 | 158,832 |
Tags: constructive algorithms, geometry
Correct Solution:
```
def f(x):
return int(x * x + 1e7)
def g(x):
return -f(x)
n, m = map(int, input().split())
if(m == 3):
if(n == 3):
print('0 0')
print('1 0')
print('0 1')
elif(n == 4):
print('0 0')
print('1 1')
print('10000 0')
print('0 10000')
else:
print(-1)
else:
for i in range(m):
print(i, f(i))
for i in range(n - m):
print(i, g(i))
``` | output | 1 | 79,416 | 23 | 158,833 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
Convexity of a set of points on the plane is the size of the largest subset of points that form a convex polygon. Your task is to build a set of n points with the convexity of exactly m. Your set of points should not contain three points that lie on a straight line.
Input
The single line contains two integers n and m (3 ≤ m ≤ 100, m ≤ n ≤ 2m).
Output
If there is no solution, print "-1". Otherwise, print n pairs of integers — the coordinates of points of any set with the convexity of m. The coordinates shouldn't exceed 108 in their absolute value.
Examples
Input
4 3
Output
0 0
3 0
0 3
1 1
Input
6 3
Output
-1
Input
6 6
Output
10 0
-10 0
10 1
9 1
9 -1
0 -2
Input
7 4
Output
176166 6377
709276 539564
654734 174109
910147 434207
790497 366519
606663 21061
859328 886001
Submitted Solution:
```
def f(x):
return int(x * x + 1e7)
def g(x):
return -f(x)
n, m = map(int, input().split())
if(m == 3):
if(n == 3):
print('0 0')
print('1 0')
print('0 1')
elif(n == 4):
print('0 0')
print('1 2')
print('3 2')
print('4 0')
else:
print(-1)
else:
for i in range(m):
print(i, f(i))
for i in range(n - m):
print(i, g(i))
``` | instruction | 0 | 79,417 | 23 | 158,834 |
No | output | 1 | 79,417 | 23 | 158,835 |
Provide a correct Python 3 solution for this coding contest problem.
We have N points in a two-dimensional plane.
The coordinates of the i-th point (1 \leq i \leq N) are (x_i,y_i).
Let us consider a rectangle whose sides are parallel to the coordinate axes that contains K or more of the N points in its interior.
Here, points on the sides of the rectangle are considered to be in the interior.
Find the minimum possible area of such a rectangle.
Constraints
* 2 \leq K \leq N \leq 50
* -10^9 \leq x_i,y_i \leq 10^9 (1 \leq i \leq N)
* x_i≠x_j (1 \leq i<j \leq N)
* y_i≠y_j (1 \leq i<j \leq N)
* All input values are integers. (Added at 21:50 JST)
Input
Input is given from Standard Input in the following format:
N K
x_1 y_1
:
x_{N} y_{N}
Output
Print the minimum possible area of a rectangle that satisfies the condition.
Examples
Input
4 4
1 4
3 3
6 2
8 1
Output
21
Input
4 2
0 0
1 1
2 2
3 3
Output
1
Input
4 3
-1000000000 -1000000000
1000000000 1000000000
-999999999 999999999
999999999 -999999999
Output
3999999996000000001 | instruction | 0 | 79,781 | 23 | 159,562 |
"Correct Solution:
```
INF = float("inf")
N, K, *XY = map(int, open(0).read().split())
X, Y = zip(*sorted(zip(*[iter(XY)] * 2)))
ans = INF
for k in range(K, N + 1):
for i in range(N - k + 1):
dx = X[i + k - 1] - X[i]
YY = sorted(Y[i:i + k])
for j in range(k - K + 1):
dy = YY[j + K - 1] - YY[j]
ans = min(ans, dx * dy)
print(ans)
``` | output | 1 | 79,781 | 23 | 159,563 |
Provide a correct Python 3 solution for this coding contest problem.
We have N points in a two-dimensional plane.
The coordinates of the i-th point (1 \leq i \leq N) are (x_i,y_i).
Let us consider a rectangle whose sides are parallel to the coordinate axes that contains K or more of the N points in its interior.
Here, points on the sides of the rectangle are considered to be in the interior.
Find the minimum possible area of such a rectangle.
Constraints
* 2 \leq K \leq N \leq 50
* -10^9 \leq x_i,y_i \leq 10^9 (1 \leq i \leq N)
* x_i≠x_j (1 \leq i<j \leq N)
* y_i≠y_j (1 \leq i<j \leq N)
* All input values are integers. (Added at 21:50 JST)
Input
Input is given from Standard Input in the following format:
N K
x_1 y_1
:
x_{N} y_{N}
Output
Print the minimum possible area of a rectangle that satisfies the condition.
Examples
Input
4 4
1 4
3 3
6 2
8 1
Output
21
Input
4 2
0 0
1 1
2 2
3 3
Output
1
Input
4 3
-1000000000 -1000000000
1000000000 1000000000
-999999999 999999999
999999999 -999999999
Output
3999999996000000001 | instruction | 0 | 79,782 | 23 | 159,564 |
"Correct Solution:
```
N,K=map(int,input().split())
point=[tuple(map(int,input().split())) for i in range(N)]
point.sort(key=lambda x:x[0])
ans=float('inf')
for i in range(1+N-K):
for j in range(i+K,N+1):
x=point[j-1][0]-point[i][0]
now=point[i:j]
now.sort(key=lambda x:x[1])
for k in range(j-i-K+1):
ans=min(x*(now[k+K-1][1]-now[k][1]),ans)
print(ans)
``` | output | 1 | 79,782 | 23 | 159,565 |
Provide a correct Python 3 solution for this coding contest problem.
We have N points in a two-dimensional plane.
The coordinates of the i-th point (1 \leq i \leq N) are (x_i,y_i).
Let us consider a rectangle whose sides are parallel to the coordinate axes that contains K or more of the N points in its interior.
Here, points on the sides of the rectangle are considered to be in the interior.
Find the minimum possible area of such a rectangle.
Constraints
* 2 \leq K \leq N \leq 50
* -10^9 \leq x_i,y_i \leq 10^9 (1 \leq i \leq N)
* x_i≠x_j (1 \leq i<j \leq N)
* y_i≠y_j (1 \leq i<j \leq N)
* All input values are integers. (Added at 21:50 JST)
Input
Input is given from Standard Input in the following format:
N K
x_1 y_1
:
x_{N} y_{N}
Output
Print the minimum possible area of a rectangle that satisfies the condition.
Examples
Input
4 4
1 4
3 3
6 2
8 1
Output
21
Input
4 2
0 0
1 1
2 2
3 3
Output
1
Input
4 3
-1000000000 -1000000000
1000000000 1000000000
-999999999 999999999
999999999 -999999999
Output
3999999996000000001 | instruction | 0 | 79,783 | 23 | 159,566 |
"Correct Solution:
```
N, K, *XY = map(int, open(0).read().split())
X, Y = zip(*sorted(zip(*[iter(XY)] * 2)))
cand = []
for k in range(K, N + 1):
for i in range(N - k + 1):
dx = X[i + k - 1] - X[i]
YY = sorted(Y[i:i + k])
cand += [min(dx * (YY[j + K - 1] - YY[j]) for j in range(k - K + 1))]
print(min(cand))
``` | output | 1 | 79,783 | 23 | 159,567 |
Provide a correct Python 3 solution for this coding contest problem.
We have N points in a two-dimensional plane.
The coordinates of the i-th point (1 \leq i \leq N) are (x_i,y_i).
Let us consider a rectangle whose sides are parallel to the coordinate axes that contains K or more of the N points in its interior.
Here, points on the sides of the rectangle are considered to be in the interior.
Find the minimum possible area of such a rectangle.
Constraints
* 2 \leq K \leq N \leq 50
* -10^9 \leq x_i,y_i \leq 10^9 (1 \leq i \leq N)
* x_i≠x_j (1 \leq i<j \leq N)
* y_i≠y_j (1 \leq i<j \leq N)
* All input values are integers. (Added at 21:50 JST)
Input
Input is given from Standard Input in the following format:
N K
x_1 y_1
:
x_{N} y_{N}
Output
Print the minimum possible area of a rectangle that satisfies the condition.
Examples
Input
4 4
1 4
3 3
6 2
8 1
Output
21
Input
4 2
0 0
1 1
2 2
3 3
Output
1
Input
4 3
-1000000000 -1000000000
1000000000 1000000000
-999999999 999999999
999999999 -999999999
Output
3999999996000000001 | instruction | 0 | 79,784 | 23 | 159,568 |
"Correct Solution:
```
n,k = map(int,input().split())
X = [0]*n
Y = [0]*n
for i in range(n):
X[i],Y[i] = map(int,input().split())
Xs = sorted(X)
Ys = sorted(Y)
XY = sorted(list(zip(X,Y)))
ans = 1e100
for i in range(n-k+1):
for j in range(i+k-1,n):
w = Xs[j] - Xs[i]
XYs = sorted(XY[i:j+1],key = lambda x:x[1])
h = 1e100
for l in range(len(XYs) - k + 1):
h = min(h, XYs[l + k - 1][1] - XYs[l][1])
ans = min(ans , h*w)
print(ans)
``` | output | 1 | 79,784 | 23 | 159,569 |
Provide a correct Python 3 solution for this coding contest problem.
We have N points in a two-dimensional plane.
The coordinates of the i-th point (1 \leq i \leq N) are (x_i,y_i).
Let us consider a rectangle whose sides are parallel to the coordinate axes that contains K or more of the N points in its interior.
Here, points on the sides of the rectangle are considered to be in the interior.
Find the minimum possible area of such a rectangle.
Constraints
* 2 \leq K \leq N \leq 50
* -10^9 \leq x_i,y_i \leq 10^9 (1 \leq i \leq N)
* x_i≠x_j (1 \leq i<j \leq N)
* y_i≠y_j (1 \leq i<j \leq N)
* All input values are integers. (Added at 21:50 JST)
Input
Input is given from Standard Input in the following format:
N K
x_1 y_1
:
x_{N} y_{N}
Output
Print the minimum possible area of a rectangle that satisfies the condition.
Examples
Input
4 4
1 4
3 3
6 2
8 1
Output
21
Input
4 2
0 0
1 1
2 2
3 3
Output
1
Input
4 3
-1000000000 -1000000000
1000000000 1000000000
-999999999 999999999
999999999 -999999999
Output
3999999996000000001 | instruction | 0 | 79,785 | 23 | 159,570 |
"Correct Solution:
```
N,K = map(int,input().split())
A = [list(map(int,input().split())) for _ in range(N)]
s = 10**19
B = sorted(A,key=lambda x:x[0])
for i in range(N-K+1):
for j in range(K,N-i+1):
xmin = B[i][0]
xmax = B[i+j-1][0]
By = sorted(B[i:i+j],key=lambda x:x[1])
for k in range(len(By)-K+1):
ymin = By[k][1]
ymax = By[k+K-1][1]
s = min(s,(xmax-xmin)*(ymax-ymin))
print(s)
``` | output | 1 | 79,785 | 23 | 159,571 |
Provide a correct Python 3 solution for this coding contest problem.
We have N points in a two-dimensional plane.
The coordinates of the i-th point (1 \leq i \leq N) are (x_i,y_i).
Let us consider a rectangle whose sides are parallel to the coordinate axes that contains K or more of the N points in its interior.
Here, points on the sides of the rectangle are considered to be in the interior.
Find the minimum possible area of such a rectangle.
Constraints
* 2 \leq K \leq N \leq 50
* -10^9 \leq x_i,y_i \leq 10^9 (1 \leq i \leq N)
* x_i≠x_j (1 \leq i<j \leq N)
* y_i≠y_j (1 \leq i<j \leq N)
* All input values are integers. (Added at 21:50 JST)
Input
Input is given from Standard Input in the following format:
N K
x_1 y_1
:
x_{N} y_{N}
Output
Print the minimum possible area of a rectangle that satisfies the condition.
Examples
Input
4 4
1 4
3 3
6 2
8 1
Output
21
Input
4 2
0 0
1 1
2 2
3 3
Output
1
Input
4 3
-1000000000 -1000000000
1000000000 1000000000
-999999999 999999999
999999999 -999999999
Output
3999999996000000001 | instruction | 0 | 79,786 | 23 | 159,572 |
"Correct Solution:
```
import sys
def LI(): return [int(x) for x in sys.stdin.readline().split()]
N,K = LI()
p = []
for i in range(N):
a,b = LI()
p.append((a,b))
sx = sorted(p)
ans = 10**50
for x,y in sx:
for x2,y2 in sx:
if x2 <= x:
continue
points = sx.index((x2,y2)) - sx.index((x,y)) + 1
if points < K:
continue
sy = sorted(sx[sx.index((x,y)):sx.index((x2,y2))+1],key=lambda sx: sx[1])
for j in range(len(sy)-K+1):
if sy[j][1] <= y and y2 <= sy[j+K-1][1]:
ans = min(ans, (x2 - x) * (sy[j+K-1][1]-sy[j][1]))
print(ans)
``` | output | 1 | 79,786 | 23 | 159,573 |
Provide a correct Python 3 solution for this coding contest problem.
We have N points in a two-dimensional plane.
The coordinates of the i-th point (1 \leq i \leq N) are (x_i,y_i).
Let us consider a rectangle whose sides are parallel to the coordinate axes that contains K or more of the N points in its interior.
Here, points on the sides of the rectangle are considered to be in the interior.
Find the minimum possible area of such a rectangle.
Constraints
* 2 \leq K \leq N \leq 50
* -10^9 \leq x_i,y_i \leq 10^9 (1 \leq i \leq N)
* x_i≠x_j (1 \leq i<j \leq N)
* y_i≠y_j (1 \leq i<j \leq N)
* All input values are integers. (Added at 21:50 JST)
Input
Input is given from Standard Input in the following format:
N K
x_1 y_1
:
x_{N} y_{N}
Output
Print the minimum possible area of a rectangle that satisfies the condition.
Examples
Input
4 4
1 4
3 3
6 2
8 1
Output
21
Input
4 2
0 0
1 1
2 2
3 3
Output
1
Input
4 3
-1000000000 -1000000000
1000000000 1000000000
-999999999 999999999
999999999 -999999999
Output
3999999996000000001 | instruction | 0 | 79,787 | 23 | 159,574 |
"Correct Solution:
```
N,K=map(int,input().split())
p = sorted([[int(_) for _ in input().split()] for i in range(N)])
a=10**20
for xi in range(N-K+1):
for xj in range(xi+K-1,N):
q = sorted(y for x,y in p[xi:xj+1])
for yi in range(xj-(xi+K-1)+1):
yj = yi+K-1 #Is the number always K?
if q[yi]<=p[xi][1] and p[xj][1]<=q[yj]:
a = min(a, (p[xi][0]-p[xj][0])*(q[yi]-q[yj]))
print(a)
``` | output | 1 | 79,787 | 23 | 159,575 |
Provide a correct Python 3 solution for this coding contest problem.
We have N points in a two-dimensional plane.
The coordinates of the i-th point (1 \leq i \leq N) are (x_i,y_i).
Let us consider a rectangle whose sides are parallel to the coordinate axes that contains K or more of the N points in its interior.
Here, points on the sides of the rectangle are considered to be in the interior.
Find the minimum possible area of such a rectangle.
Constraints
* 2 \leq K \leq N \leq 50
* -10^9 \leq x_i,y_i \leq 10^9 (1 \leq i \leq N)
* x_i≠x_j (1 \leq i<j \leq N)
* y_i≠y_j (1 \leq i<j \leq N)
* All input values are integers. (Added at 21:50 JST)
Input
Input is given from Standard Input in the following format:
N K
x_1 y_1
:
x_{N} y_{N}
Output
Print the minimum possible area of a rectangle that satisfies the condition.
Examples
Input
4 4
1 4
3 3
6 2
8 1
Output
21
Input
4 2
0 0
1 1
2 2
3 3
Output
1
Input
4 3
-1000000000 -1000000000
1000000000 1000000000
-999999999 999999999
999999999 -999999999
Output
3999999996000000001 | instruction | 0 | 79,788 | 23 | 159,576 |
"Correct Solution:
```
n, k = map(int, input().split())
p = sorted([tuple(map(int, input().split())) for i in range(n)])
ans = 4 * 10**18
for i in range(k, n + 1):
for j in range(n - i + 1): # x座標に関して j から i + j まで含む
x = p[i + j - 1][0] - p[j][0]
s = sorted([p[a][1] for a in range(j, i + j)])
y = min(s[a + k - 1] - s[a] for a in range(i - k + 1))
ans = min(ans, x * y)
print(ans)
``` | output | 1 | 79,788 | 23 | 159,577 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
We have N points in a two-dimensional plane.
The coordinates of the i-th point (1 \leq i \leq N) are (x_i,y_i).
Let us consider a rectangle whose sides are parallel to the coordinate axes that contains K or more of the N points in its interior.
Here, points on the sides of the rectangle are considered to be in the interior.
Find the minimum possible area of such a rectangle.
Constraints
* 2 \leq K \leq N \leq 50
* -10^9 \leq x_i,y_i \leq 10^9 (1 \leq i \leq N)
* x_i≠x_j (1 \leq i<j \leq N)
* y_i≠y_j (1 \leq i<j \leq N)
* All input values are integers. (Added at 21:50 JST)
Input
Input is given from Standard Input in the following format:
N K
x_1 y_1
:
x_{N} y_{N}
Output
Print the minimum possible area of a rectangle that satisfies the condition.
Examples
Input
4 4
1 4
3 3
6 2
8 1
Output
21
Input
4 2
0 0
1 1
2 2
3 3
Output
1
Input
4 3
-1000000000 -1000000000
1000000000 1000000000
-999999999 999999999
999999999 -999999999
Output
3999999996000000001
Submitted Solution:
```
n, k = map(int, input().split())
p = [tuple(map(int, input().split())) for i in range(n)]
p.sort()
ans = 4000000000000000000
for i in range(k, n + 1):
for j in range(n - i + 1):
x = p[i + j - 1][0] - p[j][0]
s = [p[a][1] for a in range(j, i + j)]
s.sort()
y = 4000000000
for a in range(i - k + 1):
y = min(y, s[a + k - 1] - s[a])
ans = min(ans, x * y)
print(ans)
``` | instruction | 0 | 79,789 | 23 | 159,578 |
Yes | output | 1 | 79,789 | 23 | 159,579 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
We have N points in a two-dimensional plane.
The coordinates of the i-th point (1 \leq i \leq N) are (x_i,y_i).
Let us consider a rectangle whose sides are parallel to the coordinate axes that contains K or more of the N points in its interior.
Here, points on the sides of the rectangle are considered to be in the interior.
Find the minimum possible area of such a rectangle.
Constraints
* 2 \leq K \leq N \leq 50
* -10^9 \leq x_i,y_i \leq 10^9 (1 \leq i \leq N)
* x_i≠x_j (1 \leq i<j \leq N)
* y_i≠y_j (1 \leq i<j \leq N)
* All input values are integers. (Added at 21:50 JST)
Input
Input is given from Standard Input in the following format:
N K
x_1 y_1
:
x_{N} y_{N}
Output
Print the minimum possible area of a rectangle that satisfies the condition.
Examples
Input
4 4
1 4
3 3
6 2
8 1
Output
21
Input
4 2
0 0
1 1
2 2
3 3
Output
1
Input
4 3
-1000000000 -1000000000
1000000000 1000000000
-999999999 999999999
999999999 -999999999
Output
3999999996000000001
Submitted Solution:
```
n, k = map(int, input().split())
XY = [list(map(int, input().split())) for _ in [0] * n]
a = XY.sort()
ans = float("inf")
for i in range(n - k + 1):
for j in range(i + k, 1 + n):
x = XY[j - 1][0] - XY[i][0]
now = XY[i:j]
now.sort(key=lambda x: x[1])
for w in range(j - i - k + 1):
ans = min(ans, x * (now[w + k - 1][1] - now[w][1]))
print(ans)
``` | instruction | 0 | 79,790 | 23 | 159,580 |
Yes | output | 1 | 79,790 | 23 | 159,581 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
We have N points in a two-dimensional plane.
The coordinates of the i-th point (1 \leq i \leq N) are (x_i,y_i).
Let us consider a rectangle whose sides are parallel to the coordinate axes that contains K or more of the N points in its interior.
Here, points on the sides of the rectangle are considered to be in the interior.
Find the minimum possible area of such a rectangle.
Constraints
* 2 \leq K \leq N \leq 50
* -10^9 \leq x_i,y_i \leq 10^9 (1 \leq i \leq N)
* x_i≠x_j (1 \leq i<j \leq N)
* y_i≠y_j (1 \leq i<j \leq N)
* All input values are integers. (Added at 21:50 JST)
Input
Input is given from Standard Input in the following format:
N K
x_1 y_1
:
x_{N} y_{N}
Output
Print the minimum possible area of a rectangle that satisfies the condition.
Examples
Input
4 4
1 4
3 3
6 2
8 1
Output
21
Input
4 2
0 0
1 1
2 2
3 3
Output
1
Input
4 3
-1000000000 -1000000000
1000000000 1000000000
-999999999 999999999
999999999 -999999999
Output
3999999996000000001
Submitted Solution:
```
n,t=map(int, input().split())
x=[]
y=[]
m=[]
for i in range(n):
a,b=map(int, input().split())
x.append(a)
y.append(b)
m.append([a,b])
x.sort()
y.sort()
ans=float('inf')
for i in range(n-1):
for j in range(i+1,n):
for k in range(n-1):
for l in range(k+1,n):
count=0
for a,b in m:
if x[i]<=a<=x[j] and y[k]<=b<=y[l]:
count+=1
if count>=t:
ans=min(ans,(x[j]-x[i])*(y[l]-y[k]))
print(ans)
``` | instruction | 0 | 79,791 | 23 | 159,582 |
Yes | output | 1 | 79,791 | 23 | 159,583 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
We have N points in a two-dimensional plane.
The coordinates of the i-th point (1 \leq i \leq N) are (x_i,y_i).
Let us consider a rectangle whose sides are parallel to the coordinate axes that contains K or more of the N points in its interior.
Here, points on the sides of the rectangle are considered to be in the interior.
Find the minimum possible area of such a rectangle.
Constraints
* 2 \leq K \leq N \leq 50
* -10^9 \leq x_i,y_i \leq 10^9 (1 \leq i \leq N)
* x_i≠x_j (1 \leq i<j \leq N)
* y_i≠y_j (1 \leq i<j \leq N)
* All input values are integers. (Added at 21:50 JST)
Input
Input is given from Standard Input in the following format:
N K
x_1 y_1
:
x_{N} y_{N}
Output
Print the minimum possible area of a rectangle that satisfies the condition.
Examples
Input
4 4
1 4
3 3
6 2
8 1
Output
21
Input
4 2
0 0
1 1
2 2
3 3
Output
1
Input
4 3
-1000000000 -1000000000
1000000000 1000000000
-999999999 999999999
999999999 -999999999
Output
3999999996000000001
Submitted Solution:
```
from itertools import combinations
N, K = map(int, input().split())
XY = [tuple(map(int, input().split())) for _ in range(N)]
ans = 10**20
for rect in combinations(XY, r=min(K, 4)):
X = [x for x, _ in rect]
Y = [y for _, y in rect]
miX, mxX = min(X), max(X)
miY, mxY = min(Y), max(Y)
cnt = len([x for x, y in XY if miY <= y <= mxY and miX <= x <= mxX])
if cnt >= K:
ans = min(ans, (mxX - miX) * (mxY - miY))
print(ans)
``` | instruction | 0 | 79,792 | 23 | 159,584 |
Yes | output | 1 | 79,792 | 23 | 159,585 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
We have N points in a two-dimensional plane.
The coordinates of the i-th point (1 \leq i \leq N) are (x_i,y_i).
Let us consider a rectangle whose sides are parallel to the coordinate axes that contains K or more of the N points in its interior.
Here, points on the sides of the rectangle are considered to be in the interior.
Find the minimum possible area of such a rectangle.
Constraints
* 2 \leq K \leq N \leq 50
* -10^9 \leq x_i,y_i \leq 10^9 (1 \leq i \leq N)
* x_i≠x_j (1 \leq i<j \leq N)
* y_i≠y_j (1 \leq i<j \leq N)
* All input values are integers. (Added at 21:50 JST)
Input
Input is given from Standard Input in the following format:
N K
x_1 y_1
:
x_{N} y_{N}
Output
Print the minimum possible area of a rectangle that satisfies the condition.
Examples
Input
4 4
1 4
3 3
6 2
8 1
Output
21
Input
4 2
0 0
1 1
2 2
3 3
Output
1
Input
4 3
-1000000000 -1000000000
1000000000 1000000000
-999999999 999999999
999999999 -999999999
Output
3999999996000000001
Submitted Solution:
```
import sys
import numpy as np
input = sys.stdin.readline
def main():
N, K = map(int, input().split())
xy = [list(map(int, input().split())) for i in range(N)]
xy = np.array(sorted(xy, key=lambda x: x[0]))
ans = int(1e20)
for i in range(N-K+1):
ans = min(ans, (xy[i+K-1][0] - xy[i][0]) * (max(xy[i:i+K, 1]) - min(xy[i:i+K, 1])))
xy = np.array(sorted(xy, key=lambda x: x[1]))
for i in range(N-K+1):
ans = min(ans, (xy[i+K-1][1] - xy[i][1]) * (max(xy[i:i+K, 0]) - min(xy[i:i+K, 0])))
print(int(ans))
if __name__ == "__main__":
main()
``` | instruction | 0 | 79,793 | 23 | 159,586 |
No | output | 1 | 79,793 | 23 | 159,587 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
We have N points in a two-dimensional plane.
The coordinates of the i-th point (1 \leq i \leq N) are (x_i,y_i).
Let us consider a rectangle whose sides are parallel to the coordinate axes that contains K or more of the N points in its interior.
Here, points on the sides of the rectangle are considered to be in the interior.
Find the minimum possible area of such a rectangle.
Constraints
* 2 \leq K \leq N \leq 50
* -10^9 \leq x_i,y_i \leq 10^9 (1 \leq i \leq N)
* x_i≠x_j (1 \leq i<j \leq N)
* y_i≠y_j (1 \leq i<j \leq N)
* All input values are integers. (Added at 21:50 JST)
Input
Input is given from Standard Input in the following format:
N K
x_1 y_1
:
x_{N} y_{N}
Output
Print the minimum possible area of a rectangle that satisfies the condition.
Examples
Input
4 4
1 4
3 3
6 2
8 1
Output
21
Input
4 2
0 0
1 1
2 2
3 3
Output
1
Input
4 3
-1000000000 -1000000000
1000000000 1000000000
-999999999 999999999
999999999 -999999999
Output
3999999996000000001
Submitted Solution:
```
n,k=map(int,input().split())
z=sorted(list(map(int,input().split()))for _ in range(n))
a=10**30
for i,j in zip(range(n),range(k-1,n)):
m,M=10**18,-10**18
for(_,b)in z[i:j+1]:
m=min(m,b)
M=max(M,b)
a=min(a,(M-m)*(z[j][0]-z[i][0]))
print(a)
``` | instruction | 0 | 79,794 | 23 | 159,588 |
No | output | 1 | 79,794 | 23 | 159,589 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
We have N points in a two-dimensional plane.
The coordinates of the i-th point (1 \leq i \leq N) are (x_i,y_i).
Let us consider a rectangle whose sides are parallel to the coordinate axes that contains K or more of the N points in its interior.
Here, points on the sides of the rectangle are considered to be in the interior.
Find the minimum possible area of such a rectangle.
Constraints
* 2 \leq K \leq N \leq 50
* -10^9 \leq x_i,y_i \leq 10^9 (1 \leq i \leq N)
* x_i≠x_j (1 \leq i<j \leq N)
* y_i≠y_j (1 \leq i<j \leq N)
* All input values are integers. (Added at 21:50 JST)
Input
Input is given from Standard Input in the following format:
N K
x_1 y_1
:
x_{N} y_{N}
Output
Print the minimum possible area of a rectangle that satisfies the condition.
Examples
Input
4 4
1 4
3 3
6 2
8 1
Output
21
Input
4 2
0 0
1 1
2 2
3 3
Output
1
Input
4 3
-1000000000 -1000000000
1000000000 1000000000
-999999999 999999999
999999999 -999999999
Output
3999999996000000001
Submitted Solution:
```
N, K = map(int, input().split())
XY = [list(map(int, input().split())) for _ in range(N)]
XY.sort()
XY_Y = sorted(XY, key = lambda x: x[1])
def count(x_min, x_max, y_min, y_max, i, j):
OK = 0
NG = 0
a = j - i + 1 - K
for m in range(i, j + 1):
if y_min <= XY[m][1] <= y_max:
OK += 1
else:
NG += 1
if OK >= K:
return True
if NG > a:
return False
ans = 10 ** 19
for i in range(N - 1):
for j in range(i + K - 1, N):
for k in range(N - 1):
for l in range(i + K - 1, N):
if count(XY[i][0], XY[j][0], XY_Y[k][1], XY_Y[l][1], i, j):
# print ('A')
ans = min(ans, (XY[j][0] - XY[i][0]) * (XY_Y[l][1] - XY_Y[k][1]))
print (ans)
``` | instruction | 0 | 79,795 | 23 | 159,590 |
No | output | 1 | 79,795 | 23 | 159,591 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
We have N points in a two-dimensional plane.
The coordinates of the i-th point (1 \leq i \leq N) are (x_i,y_i).
Let us consider a rectangle whose sides are parallel to the coordinate axes that contains K or more of the N points in its interior.
Here, points on the sides of the rectangle are considered to be in the interior.
Find the minimum possible area of such a rectangle.
Constraints
* 2 \leq K \leq N \leq 50
* -10^9 \leq x_i,y_i \leq 10^9 (1 \leq i \leq N)
* x_i≠x_j (1 \leq i<j \leq N)
* y_i≠y_j (1 \leq i<j \leq N)
* All input values are integers. (Added at 21:50 JST)
Input
Input is given from Standard Input in the following format:
N K
x_1 y_1
:
x_{N} y_{N}
Output
Print the minimum possible area of a rectangle that satisfies the condition.
Examples
Input
4 4
1 4
3 3
6 2
8 1
Output
21
Input
4 2
0 0
1 1
2 2
3 3
Output
1
Input
4 3
-1000000000 -1000000000
1000000000 1000000000
-999999999 999999999
999999999 -999999999
Output
3999999996000000001
Submitted Solution:
```
from collections import defaultdict
def main():
n,k=map(int,input().split())
xy=[list(map(int,input().split())) for _ in range(n)]
xwl=dict((c[0],i) for i,c in enumerate(xy))
ywl=dict((c[1],i) for i,c in enumerate(xy))
x=list(xwl.keys())
y=list(ywl.keys())
x.sort()
y.sort()
xdict=dict()
ydict=dict()
xdict[x[0]]=[1<<xwl[x[0]],0]
ydict[y[0]]=[1<<ywl[y[0]],0]
size=lambda x:sum(x>>i&1 for i in range(n))
minus=lambda x,y:(x|y)^y
for i in range(1,n):
xdict[x[i]]=[xdict[x[i-1]][0]|(1<<xwl[x[i]]), xdict[x[i-1]][1]|(1<<xwl[x[i-1]])]
ydict[y[i]]=[ydict[y[i-1]][0]|(1<<ywl[y[i]]), ydict[y[i-1]][1]|(1<<ywl[y[i-1]])]
ans=float('inf')
for s in range(n):
for t in range(s+1,n):
for u in range(n):
for v in range(u+1,n):
if size(minus(xdict[x[t]][0],xdict[x[s]][1])&\
minus(ydict[y[v]][0],ydict[y[u]][1]))>=k:
ans=min(ans,(x[t]-x[s])*(y[v]-y[u]))
print(ans)
if __name__=='__main__':
main()
``` | instruction | 0 | 79,796 | 23 | 159,592 |
No | output | 1 | 79,796 | 23 | 159,593 |
Provide a correct Python 3 solution for this coding contest problem.
Create a program that rotates the pattern of 8 characters x 8 lines clockwise by 90 degrees, 180 degrees, and 270 degrees and outputs it.
Input
A pattern consisting of 8 characters x 8 lines is given. Characters consist of alphanumeric characters, half-width pound'#', and asterisk'*'.
Output
Output the rotated pattern in the following format.
90 (fixed half-width numbers)
Pattern rotated 90 degrees
180 (fixed half-width numbers)
180 degree rotated pattern
270 (fixed half-width numbers)
Pattern rotated 270 degrees
Examples
Input
#*******
#*******
#*******
#*******
#*******
#*******
#*******
########
Output
90
########
#*******
#*******
#*******
#*******
#*******
#*******
#*******
180
########
*******#
*******#
*******#
*******#
*******#
*******#
*******#
270
*******#
*******#
*******#
*******#
*******#
*******#
*******#
########
Input
*******
*******
*******
*******
*******
*******
*******
Output
90
*******
*******
*******
*******
*******
*******
*******
180
*******#
*******#
*******#
*******#
*******#
*******#
*******#
270
*******#
*******#
*******#
*******#
*******#
*******#
*******# | instruction | 0 | 79,835 | 23 | 159,670 |
"Correct Solution:
```
#写経させていただきました。
def spin(p):
ret = [[None] * 8 for _ in range(8)]
for i in range(8):
for j in range(8):
ret[i][j] = p[7 - j][i]
return ret
def print_p(p):
for line in p:
print("".join(line))
p = [input() for _ in range(8)]
print(90)
p = spin(p)
print_p(p)
print(180)
p = spin(p)
print_p(p)
print(270)
p = spin(p)
print_p(p)
``` | output | 1 | 79,835 | 23 | 159,671 |
Provide a correct Python 3 solution for this coding contest problem.
Create a program that rotates the pattern of 8 characters x 8 lines clockwise by 90 degrees, 180 degrees, and 270 degrees and outputs it.
Input
A pattern consisting of 8 characters x 8 lines is given. Characters consist of alphanumeric characters, half-width pound'#', and asterisk'*'.
Output
Output the rotated pattern in the following format.
90 (fixed half-width numbers)
Pattern rotated 90 degrees
180 (fixed half-width numbers)
180 degree rotated pattern
270 (fixed half-width numbers)
Pattern rotated 270 degrees
Examples
Input
#*******
#*******
#*******
#*******
#*******
#*******
#*******
########
Output
90
########
#*******
#*******
#*******
#*******
#*******
#*******
#*******
180
########
*******#
*******#
*******#
*******#
*******#
*******#
*******#
270
*******#
*******#
*******#
*******#
*******#
*******#
*******#
########
Input
*******
*******
*******
*******
*******
*******
*******
Output
90
*******
*******
*******
*******
*******
*******
*******
180
*******#
*******#
*******#
*******#
*******#
*******#
*******#
270
*******#
*******#
*******#
*******#
*******#
*******#
*******# | instruction | 0 | 79,836 | 23 | 159,672 |
"Correct Solution:
```
def spin(pazzule):
pzl = [["" for i in range(8)] for j in range(8)]
for i in range(8):
for j in range(8):
pzl[i][j] = pazzule[7-j][i]
return pzl
pazzule = [list(input()) for i in range(8)]
pazzule = spin(pazzule)
print("90")
for i in range(8):
print("".join(pazzule[i]))
print("180")
pazzule = spin(pazzule)
for i in range(8):
print("".join(pazzule[i]))
print("270")
pazzule = spin(pazzule)
for i in range(8):
print("".join(pazzule[i]))
``` | output | 1 | 79,836 | 23 | 159,673 |
Provide a correct Python 3 solution for this coding contest problem.
Create a program that rotates the pattern of 8 characters x 8 lines clockwise by 90 degrees, 180 degrees, and 270 degrees and outputs it.
Input
A pattern consisting of 8 characters x 8 lines is given. Characters consist of alphanumeric characters, half-width pound'#', and asterisk'*'.
Output
Output the rotated pattern in the following format.
90 (fixed half-width numbers)
Pattern rotated 90 degrees
180 (fixed half-width numbers)
180 degree rotated pattern
270 (fixed half-width numbers)
Pattern rotated 270 degrees
Examples
Input
#*******
#*******
#*******
#*******
#*******
#*******
#*******
########
Output
90
########
#*******
#*******
#*******
#*******
#*******
#*******
#*******
180
########
*******#
*******#
*******#
*******#
*******#
*******#
*******#
270
*******#
*******#
*******#
*******#
*******#
*******#
*******#
########
Input
*******
*******
*******
*******
*******
*******
*******
Output
90
*******
*******
*******
*******
*******
*******
*******
180
*******#
*******#
*******#
*******#
*******#
*******#
*******#
270
*******#
*******#
*******#
*******#
*******#
*******#
*******# | instruction | 0 | 79,837 | 23 | 159,674 |
"Correct Solution:
```
mat = []
for _ in range(8):
mat.append(list(input()))
mat90 = [[0 for i in range(8)] for j in range(8)]
print(90)
for i in range(8):
for j in range(8):
mat90[i][j] = mat[7-j][i]
for i in range(8):
print(''.join(m for m in mat90[i]))
mat180 = [[0 for i in range(8)] for j in range(8)]
print(180)
for i in range(8):
for j in range(8):
mat180[i][j] = mat90[7-j][i]
for i in range(8):
print(''.join(m for m in mat180[i]))
mat270 = [[0 for i in range(8)] for j in range(8)]
print(270)
for i in range(8):
for j in range(8):
mat270[i][j] = mat180[7-j][i]
for i in range(8):
print(''.join(m for m in mat270[i]))
``` | output | 1 | 79,837 | 23 | 159,675 |
Provide a correct Python 3 solution for this coding contest problem.
Create a program that rotates the pattern of 8 characters x 8 lines clockwise by 90 degrees, 180 degrees, and 270 degrees and outputs it.
Input
A pattern consisting of 8 characters x 8 lines is given. Characters consist of alphanumeric characters, half-width pound'#', and asterisk'*'.
Output
Output the rotated pattern in the following format.
90 (fixed half-width numbers)
Pattern rotated 90 degrees
180 (fixed half-width numbers)
180 degree rotated pattern
270 (fixed half-width numbers)
Pattern rotated 270 degrees
Examples
Input
#*******
#*******
#*******
#*******
#*******
#*******
#*******
########
Output
90
########
#*******
#*******
#*******
#*******
#*******
#*******
#*******
180
########
*******#
*******#
*******#
*******#
*******#
*******#
*******#
270
*******#
*******#
*******#
*******#
*******#
*******#
*******#
########
Input
*******
*******
*******
*******
*******
*******
*******
Output
90
*******
*******
*******
*******
*******
*******
*******
180
*******#
*******#
*******#
*******#
*******#
*******#
*******#
270
*******#
*******#
*******#
*******#
*******#
*******#
*******# | instruction | 0 | 79,838 | 23 | 159,676 |
"Correct Solution:
```
# AOJ 0133 Rotation of a Pattern
# Python3 2018.6.19 bal4u
a = [[[0 for c in range(8)] for r in range(8)] for k in range(4)]
title = ["0", "90", "180", "270"]
for r in range(8):
a[0][r] = list(input())
for k in range(1, 4):
print(title[k])
for r in range(8):
for c in range(8):
a[k][c][7-r] = a[k-1][r][c]
for r in range(8): print(*a[k][r], sep='')
``` | output | 1 | 79,838 | 23 | 159,677 |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.