message stringlengths 2 44.5k | message_type stringclasses 2 values | message_id int64 0 1 | conversation_id int64 276 109k | cluster float64 23 23 | __index_level_0__ int64 552 217k |
|---|---|---|---|---|---|
Provide tags and a correct Python 3 solution for this coding contest problem.
A big company decided to launch a new series of rectangular displays, and decided that the display must have exactly n pixels.
Your task is to determine the size of the rectangular display — the number of lines (rows) of pixels a and the number of columns of pixels b, so that:
* there are exactly n pixels on the display;
* the number of rows does not exceed the number of columns, it means a ≤ b;
* the difference b - a is as small as possible.
Input
The first line contains the positive integer n (1 ≤ n ≤ 106) — the number of pixels display should have.
Output
Print two integers — the number of rows and columns on the display.
Examples
Input
8
Output
2 4
Input
64
Output
8 8
Input
5
Output
1 5
Input
999999
Output
999 1001
Note
In the first example the minimum possible difference equals 2, so on the display should be 2 rows of 4 pixels.
In the second example the minimum possible difference equals 0, so on the display should be 8 rows of 8 pixels.
In the third example the minimum possible difference equals 4, so on the display should be 1 row of 5 pixels. | instruction | 0 | 92,255 | 23 | 184,510 |
Tags: brute force, math
Correct Solution:
```
def isPrime(n):
if(n<=2):
return 1
for i in range(2,n):
if(n%i==0):
return 0
return 1
n=int(input().strip())
s=n**0.5
if(isPrime(n)):
print(1,n)
elif(s==int(s)):
print(int(s),int(s))
else:
s=int(s)
# print(s)
for i in range(s,n//2 + 1):
if(n%i==0):
print(int(min(n//i,i)),int(max(n//i,i)))
break
``` | output | 1 | 92,255 | 23 | 184,511 |
Provide tags and a correct Python 3 solution for this coding contest problem.
A big company decided to launch a new series of rectangular displays, and decided that the display must have exactly n pixels.
Your task is to determine the size of the rectangular display — the number of lines (rows) of pixels a and the number of columns of pixels b, so that:
* there are exactly n pixels on the display;
* the number of rows does not exceed the number of columns, it means a ≤ b;
* the difference b - a is as small as possible.
Input
The first line contains the positive integer n (1 ≤ n ≤ 106) — the number of pixels display should have.
Output
Print two integers — the number of rows and columns on the display.
Examples
Input
8
Output
2 4
Input
64
Output
8 8
Input
5
Output
1 5
Input
999999
Output
999 1001
Note
In the first example the minimum possible difference equals 2, so on the display should be 2 rows of 4 pixels.
In the second example the minimum possible difference equals 0, so on the display should be 8 rows of 8 pixels.
In the third example the minimum possible difference equals 4, so on the display should be 1 row of 5 pixels. | instruction | 0 | 92,256 | 23 | 184,512 |
Tags: brute force, math
Correct Solution:
```
n = int(input())
res = 10000000
a = 0
b = 0
i = 1
while i * i <= n:
if n % i == 0:
a = i
b = n // i
i += 1
print(a, b)
``` | output | 1 | 92,256 | 23 | 184,513 |
Provide tags and a correct Python 3 solution for this coding contest problem.
A big company decided to launch a new series of rectangular displays, and decided that the display must have exactly n pixels.
Your task is to determine the size of the rectangular display — the number of lines (rows) of pixels a and the number of columns of pixels b, so that:
* there are exactly n pixels on the display;
* the number of rows does not exceed the number of columns, it means a ≤ b;
* the difference b - a is as small as possible.
Input
The first line contains the positive integer n (1 ≤ n ≤ 106) — the number of pixels display should have.
Output
Print two integers — the number of rows and columns on the display.
Examples
Input
8
Output
2 4
Input
64
Output
8 8
Input
5
Output
1 5
Input
999999
Output
999 1001
Note
In the first example the minimum possible difference equals 2, so on the display should be 2 rows of 4 pixels.
In the second example the minimum possible difference equals 0, so on the display should be 8 rows of 8 pixels.
In the third example the minimum possible difference equals 4, so on the display should be 1 row of 5 pixels. | instruction | 0 | 92,257 | 23 | 184,514 |
Tags: brute force, math
Correct Solution:
```
import sys
noOfPixels = int(input())
if noOfPixels == 1:
print("1 1")
else:
row=1
mini = sys.maxsize
ans = []
while True:
if noOfPixels%row==0:
col = noOfPixels//row
if row > col:
break
mini = min(mini,(col-row))
ans[:] = []
ans.append(row)
ans.append(col)
row = row+1
print(ans[0],ans[1])
``` | output | 1 | 92,257 | 23 | 184,515 |
Provide tags and a correct Python 3 solution for this coding contest problem.
A big company decided to launch a new series of rectangular displays, and decided that the display must have exactly n pixels.
Your task is to determine the size of the rectangular display — the number of lines (rows) of pixels a and the number of columns of pixels b, so that:
* there are exactly n pixels on the display;
* the number of rows does not exceed the number of columns, it means a ≤ b;
* the difference b - a is as small as possible.
Input
The first line contains the positive integer n (1 ≤ n ≤ 106) — the number of pixels display should have.
Output
Print two integers — the number of rows and columns on the display.
Examples
Input
8
Output
2 4
Input
64
Output
8 8
Input
5
Output
1 5
Input
999999
Output
999 1001
Note
In the first example the minimum possible difference equals 2, so on the display should be 2 rows of 4 pixels.
In the second example the minimum possible difference equals 0, so on the display should be 8 rows of 8 pixels.
In the third example the minimum possible difference equals 4, so on the display should be 1 row of 5 pixels. | instruction | 0 | 92,258 | 23 | 184,516 |
Tags: brute force, math
Correct Solution:
```
num = int(input())
mn = float("inf")
ans = []
for i in range(1, int(num**0.5)+1):
if num % i == 0:
ans = [i, num//i]
print(*ans)
``` | output | 1 | 92,258 | 23 | 184,517 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
A big company decided to launch a new series of rectangular displays, and decided that the display must have exactly n pixels.
Your task is to determine the size of the rectangular display — the number of lines (rows) of pixels a and the number of columns of pixels b, so that:
* there are exactly n pixels on the display;
* the number of rows does not exceed the number of columns, it means a ≤ b;
* the difference b - a is as small as possible.
Input
The first line contains the positive integer n (1 ≤ n ≤ 106) — the number of pixels display should have.
Output
Print two integers — the number of rows and columns on the display.
Examples
Input
8
Output
2 4
Input
64
Output
8 8
Input
5
Output
1 5
Input
999999
Output
999 1001
Note
In the first example the minimum possible difference equals 2, so on the display should be 2 rows of 4 pixels.
In the second example the minimum possible difference equals 0, so on the display should be 8 rows of 8 pixels.
In the third example the minimum possible difference equals 4, so on the display should be 1 row of 5 pixels.
Submitted Solution:
```
#!/bin/python3
# challenge-url: http://codeforces.com/contest/747/problem/A
# username: hudson
# n: number of pixels
# a: number of rows of pixels
# b: number of pixel columns
import math
n = int(input())
div = int( math.sqrt(n) )
while n % div != 0 and div != 1:
div -= 1
print( div, n // div)
``` | instruction | 0 | 92,259 | 23 | 184,518 |
Yes | output | 1 | 92,259 | 23 | 184,519 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
A big company decided to launch a new series of rectangular displays, and decided that the display must have exactly n pixels.
Your task is to determine the size of the rectangular display — the number of lines (rows) of pixels a and the number of columns of pixels b, so that:
* there are exactly n pixels on the display;
* the number of rows does not exceed the number of columns, it means a ≤ b;
* the difference b - a is as small as possible.
Input
The first line contains the positive integer n (1 ≤ n ≤ 106) — the number of pixels display should have.
Output
Print two integers — the number of rows and columns on the display.
Examples
Input
8
Output
2 4
Input
64
Output
8 8
Input
5
Output
1 5
Input
999999
Output
999 1001
Note
In the first example the minimum possible difference equals 2, so on the display should be 2 rows of 4 pixels.
In the second example the minimum possible difference equals 0, so on the display should be 8 rows of 8 pixels.
In the third example the minimum possible difference equals 4, so on the display should be 1 row of 5 pixels.
Submitted Solution:
```
n = int(input())
a = 1
b = n
for i in range(2, int(n**.5)+1):
if n % i == 0:
a = i
b = n//i
print(a,b)
``` | instruction | 0 | 92,260 | 23 | 184,520 |
Yes | output | 1 | 92,260 | 23 | 184,521 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
A big company decided to launch a new series of rectangular displays, and decided that the display must have exactly n pixels.
Your task is to determine the size of the rectangular display — the number of lines (rows) of pixels a and the number of columns of pixels b, so that:
* there are exactly n pixels on the display;
* the number of rows does not exceed the number of columns, it means a ≤ b;
* the difference b - a is as small as possible.
Input
The first line contains the positive integer n (1 ≤ n ≤ 106) — the number of pixels display should have.
Output
Print two integers — the number of rows and columns on the display.
Examples
Input
8
Output
2 4
Input
64
Output
8 8
Input
5
Output
1 5
Input
999999
Output
999 1001
Note
In the first example the minimum possible difference equals 2, so on the display should be 2 rows of 4 pixels.
In the second example the minimum possible difference equals 0, so on the display should be 8 rows of 8 pixels.
In the third example the minimum possible difference equals 4, so on the display should be 1 row of 5 pixels.
Submitted Solution:
```
n=int(input())
b,a=n,1
while(b>0 and b>=int(n/b)):
if(n%b==0):
small=b
b-=1
print(int(n/small),small)
``` | instruction | 0 | 92,261 | 23 | 184,522 |
Yes | output | 1 | 92,261 | 23 | 184,523 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
A big company decided to launch a new series of rectangular displays, and decided that the display must have exactly n pixels.
Your task is to determine the size of the rectangular display — the number of lines (rows) of pixels a and the number of columns of pixels b, so that:
* there are exactly n pixels on the display;
* the number of rows does not exceed the number of columns, it means a ≤ b;
* the difference b - a is as small as possible.
Input
The first line contains the positive integer n (1 ≤ n ≤ 106) — the number of pixels display should have.
Output
Print two integers — the number of rows and columns on the display.
Examples
Input
8
Output
2 4
Input
64
Output
8 8
Input
5
Output
1 5
Input
999999
Output
999 1001
Note
In the first example the minimum possible difference equals 2, so on the display should be 2 rows of 4 pixels.
In the second example the minimum possible difference equals 0, so on the display should be 8 rows of 8 pixels.
In the third example the minimum possible difference equals 4, so on the display should be 1 row of 5 pixels.
Submitted Solution:
```
n=int(input())
a=1
for i in range(2,int(n**0.5)+2):
if n%i==0:
a=i
print(min(a,n//a),max(a,n//a))
``` | instruction | 0 | 92,262 | 23 | 184,524 |
Yes | output | 1 | 92,262 | 23 | 184,525 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
A big company decided to launch a new series of rectangular displays, and decided that the display must have exactly n pixels.
Your task is to determine the size of the rectangular display — the number of lines (rows) of pixels a and the number of columns of pixels b, so that:
* there are exactly n pixels on the display;
* the number of rows does not exceed the number of columns, it means a ≤ b;
* the difference b - a is as small as possible.
Input
The first line contains the positive integer n (1 ≤ n ≤ 106) — the number of pixels display should have.
Output
Print two integers — the number of rows and columns on the display.
Examples
Input
8
Output
2 4
Input
64
Output
8 8
Input
5
Output
1 5
Input
999999
Output
999 1001
Note
In the first example the minimum possible difference equals 2, so on the display should be 2 rows of 4 pixels.
In the second example the minimum possible difference equals 0, so on the display should be 8 rows of 8 pixels.
In the third example the minimum possible difference equals 4, so on the display should be 1 row of 5 pixels.
Submitted Solution:
```
import math
n = int(input())
for i in range(math.ceil(math.sqrt(n)), 0, -1):
if n % i == 0:
print(str(i) + " " + str(int(n/i)))
break
``` | instruction | 0 | 92,263 | 23 | 184,526 |
No | output | 1 | 92,263 | 23 | 184,527 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
A big company decided to launch a new series of rectangular displays, and decided that the display must have exactly n pixels.
Your task is to determine the size of the rectangular display — the number of lines (rows) of pixels a and the number of columns of pixels b, so that:
* there are exactly n pixels on the display;
* the number of rows does not exceed the number of columns, it means a ≤ b;
* the difference b - a is as small as possible.
Input
The first line contains the positive integer n (1 ≤ n ≤ 106) — the number of pixels display should have.
Output
Print two integers — the number of rows and columns on the display.
Examples
Input
8
Output
2 4
Input
64
Output
8 8
Input
5
Output
1 5
Input
999999
Output
999 1001
Note
In the first example the minimum possible difference equals 2, so on the display should be 2 rows of 4 pixels.
In the second example the minimum possible difference equals 0, so on the display should be 8 rows of 8 pixels.
In the third example the minimum possible difference equals 4, so on the display should be 1 row of 5 pixels.
Submitted Solution:
```
import math
n=int(input())
a=1
b=n
sq=math.sqrt(n)
sq=int(sq)
for i in range (sq+1, 1, -1):
if n%i==0:
a=i
b=n/i
break
b=int(b)
a=int(a)
print(a,b)
``` | instruction | 0 | 92,264 | 23 | 184,528 |
No | output | 1 | 92,264 | 23 | 184,529 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
A big company decided to launch a new series of rectangular displays, and decided that the display must have exactly n pixels.
Your task is to determine the size of the rectangular display — the number of lines (rows) of pixels a and the number of columns of pixels b, so that:
* there are exactly n pixels on the display;
* the number of rows does not exceed the number of columns, it means a ≤ b;
* the difference b - a is as small as possible.
Input
The first line contains the positive integer n (1 ≤ n ≤ 106) — the number of pixels display should have.
Output
Print two integers — the number of rows and columns on the display.
Examples
Input
8
Output
2 4
Input
64
Output
8 8
Input
5
Output
1 5
Input
999999
Output
999 1001
Note
In the first example the minimum possible difference equals 2, so on the display should be 2 rows of 4 pixels.
In the second example the minimum possible difference equals 0, so on the display should be 8 rows of 8 pixels.
In the third example the minimum possible difference equals 4, so on the display should be 1 row of 5 pixels.
Submitted Solution:
```
n = int(input())
def rows_columns(num):
lis = []
for i in range(1, num+1):
if num%i == 0:
lis.append(i)
size = len(lis)
mid = size//2
if size%2 == 0:
return lis[mid-1], lis[mid]
else:
return lis[mid-1], lis[mid+1]
a, b = rows_columns(n)
``` | instruction | 0 | 92,265 | 23 | 184,530 |
No | output | 1 | 92,265 | 23 | 184,531 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
A big company decided to launch a new series of rectangular displays, and decided that the display must have exactly n pixels.
Your task is to determine the size of the rectangular display — the number of lines (rows) of pixels a and the number of columns of pixels b, so that:
* there are exactly n pixels on the display;
* the number of rows does not exceed the number of columns, it means a ≤ b;
* the difference b - a is as small as possible.
Input
The first line contains the positive integer n (1 ≤ n ≤ 106) — the number of pixels display should have.
Output
Print two integers — the number of rows and columns on the display.
Examples
Input
8
Output
2 4
Input
64
Output
8 8
Input
5
Output
1 5
Input
999999
Output
999 1001
Note
In the first example the minimum possible difference equals 2, so on the display should be 2 rows of 4 pixels.
In the second example the minimum possible difference equals 0, so on the display should be 8 rows of 8 pixels.
In the third example the minimum possible difference equals 4, so on the display should be 1 row of 5 pixels.
Submitted Solution:
```
n = int(input())
for i in range(int(n ** .5), 1, -1):
if n == 5:
exit(print(1, 5))
if n == 1:
exit(print(1, 1))
if n % i == 0:
exit(print(i, n // i))
# هوفففف
# خیلی نگران بودم
# امیدوارم اوکی بشه
# استرس همراه با نگرانی چیز عجیبیه
# k0P MzMMSFp
``` | instruction | 0 | 92,266 | 23 | 184,532 |
No | output | 1 | 92,266 | 23 | 184,533 |
Provide tags and a correct Python 3 solution for this coding contest problem.
You are given a set of n points on the plane. A line containing the origin is called good, if projection of the given set to this line forms a symmetric multiset of points. Find the total number of good lines.
Multiset is a set where equal elements are allowed.
Multiset is called symmetric, if there is a point P on the plane such that the multiset is [centrally symmetric](https://en.wikipedia.org/wiki/Point_reflection) in respect of point P.
Input
The first line contains a single integer n (1 ≤ n ≤ 2000) — the number of points in the set.
Each of the next n lines contains two integers xi and yi ( - 106 ≤ xi, yi ≤ 106) — the coordinates of the points. It is guaranteed that no two points coincide.
Output
If there are infinitely many good lines, print -1.
Otherwise, print single integer — the number of good lines.
Examples
Input
3
1 2
2 1
3 3
Output
3
Input
2
4 3
1 2
Output
-1
Note
Picture to the first sample test:
<image>
In the second sample, any line containing the origin is good. | instruction | 0 | 92,319 | 23 | 184,638 |
Tags: geometry
Correct Solution:
```
from fractions import Fraction
import time
class Point:
def __init__(self, x, y):
self.x = x
self.y = y
def to_tuple(self):
return (self.x, self.y)
def __repr__(self):
return "Point({}, {})".format(self.x, self.y)
def __eq__(self, other):
return self.to_tuple() == other.to_tuple()
def __hash__(self):
return hash(self.to_tuple())
def __neg__(self):
return Point(-self.x, -self.y)
def __add__(self, other):
return Point(self.x+other.x, self.y+other.y)
def __sub__(self, other):
return self+(-other)
def scalar_mul(self, mu):
return Point(mu*self.x, mu*self.y)
def int_divide(self, den):
return Point(self.x//den, self.y//den)
class Line:
def __init__(self, a, b, c):
# ax+by+c=0
self.a = a
self.b = b
self.c = c
def __repr__(self):
return "{}*x + {}*y + {} = 0".format(self.a, self.b, self.c)
@classmethod
def between_two_points(cls, P, Q):
return cls(P.y-Q.y, Q.x-P.x, P.x*Q.y-P.y*Q.x)
def evaluate(self, P):
return self.a*P.x+self.b*P.y+self.c
def direction(self):
if self.a == 0:
return (0, 1)
return (1, Fraction(self.b, self.a))
true_start = time.time()
n = int(input())
points = set()
center = Point(0, 0)
for i in range(n):
row = input().split(" ")
cur = Point(int(row[0]), int(row[1])).scalar_mul(2*n)
center += cur
points.add(cur)
center = center.int_divide(n)
dcenter = center+center
sym_points_set = set()
for p in points:
sym_points_set.add(dcenter-p)
nosym = list(points - sym_points_set)
if len(nosym) == 0:
print(-1)
exit(0)
cnt = 0
p0 = nosym[0]
good_lines = set()
for p in nosym:
m = (p+p0).int_divide(2)
line = Line.between_two_points(m, center)
distances = list(map(line.evaluate, nosym))
ok = True
mydict = {}
for dd in distances:
dda = abs(dd)
if dda not in mydict:
mydict[dda] = 1
else:
mydict[dda] += 1
for k in mydict:
if mydict[k] % 2 == 1 and k != 0:
ok = False
break
if ok:
good_lines.add(line.direction())
print(len(good_lines))
``` | output | 1 | 92,319 | 23 | 184,639 |
Provide tags and a correct Python 3 solution for this coding contest problem.
You are given a set of n points on the plane. A line containing the origin is called good, if projection of the given set to this line forms a symmetric multiset of points. Find the total number of good lines.
Multiset is a set where equal elements are allowed.
Multiset is called symmetric, if there is a point P on the plane such that the multiset is [centrally symmetric](https://en.wikipedia.org/wiki/Point_reflection) in respect of point P.
Input
The first line contains a single integer n (1 ≤ n ≤ 2000) — the number of points in the set.
Each of the next n lines contains two integers xi and yi ( - 106 ≤ xi, yi ≤ 106) — the coordinates of the points. It is guaranteed that no two points coincide.
Output
If there are infinitely many good lines, print -1.
Otherwise, print single integer — the number of good lines.
Examples
Input
3
1 2
2 1
3 3
Output
3
Input
2
4 3
1 2
Output
-1
Note
Picture to the first sample test:
<image>
In the second sample, any line containing the origin is good. | instruction | 0 | 92,320 | 23 | 184,640 |
Tags: geometry
Correct Solution:
```
from fractions import Fraction
import time
from collections import Counter
class Point:
def __init__(self, x, y):
self.x = x
self.y = y
def to_tuple(self):
return (self.x, self.y)
def __repr__(self):
return "Point({}, {})".format(self.x, self.y)
def __eq__(self, other):
return self.to_tuple() == other.to_tuple()
def __hash__(self):
return hash(self.to_tuple())
def __neg__(self):
return Point(-self.x, -self.y)
def __add__(self, other):
return Point(self.x+other.x, self.y+other.y)
def __sub__(self, other):
return self+(-other)
def scalar_mul(self, mu):
return Point(mu*self.x, mu*self.y)
def int_divide(self, den):
return Point(self.x//den, self.y//den)
def __lt__(self, other):
if self.x == other.x:
return self.y < other.y
return self.x < other.x
def dot(self, other):
return self.x*other.x+self.y*other.y
class Line:
def __init__(self, a, b, c):
# ax+by+c=0
self.a = a
self.b = b
self.c = c
def __repr__(self):
return "{}*x + {}*y + {} = 0".format(self.a, self.b, self.c)
@classmethod
def between_two_points(cls, P, Q):
return cls(P.y-Q.y, Q.x-P.x, P.x*Q.y-P.y*Q.x)
def evaluate(self, P):
return self.a*P.x+self.b*P.y+self.c
def direction(self):
if self.a == 0:
return (0, 1)
return (1, Fraction(self.b, self.a))
true_start = time.time()
n = int(input())
points = set()
center = Point(0, 0)
for i in range(n):
row = input().split(" ")
cur = Point(int(row[0]), int(row[1])).scalar_mul(2*n)
center += cur
points.add(cur)
center = center.int_divide(n)
dcenter = center+center
# nosym = []
# for p in points:
# psym = dcenter-p
# if psym not in points:
# nosym.append(p)
sym_points_set = set()
for p in points:
sym_points_set.add(dcenter-p)
nosym = list(points - sym_points_set)
#print(nosym)
# print("preproc:", time.time()-true_start)
if len(nosym) == 0:
print(-1)
exit(0)
cnt = 0
p0 = nosym[0]
good_lines = set()
for p in nosym:
start = time.time()
m = (p+p0).int_divide(2)
supp = Line.between_two_points(m, center)
time_setup = time.time()-start
distances = list(map(supp.evaluate, nosym))
time_projs = time.time()-start
# sorting strat
ok = True
SORTING = False
if SORTING:
distances = sorted(distances)
time_sorting = time.time()-start
m = len(distances)
for i in range(m//2):
if distances[i] != -distances[m-1-i]:
ok = False
break
else:
mydict = {}
for dd in distances:
dda = abs(dd)
if dda not in mydict:
mydict[dda] = 1
else:
mydict[dda] += 1
time_sorting = time.time()-start
for k in mydict:
if mydict[k] % 2 == 1 and k != 0:
ok = False
break
if ok:
#print("ok", supp)
#print(distances)
#print(mydict)
good_lines.add(supp.direction())
#print("setup: {}\tprojs: {}\tsort: {}\tdone: {}".format(time_setup, time_projs, time_sorting, time.time()-start))
#print("total:", time.time()-true_start)
print(len(good_lines))
``` | output | 1 | 92,320 | 23 | 184,641 |
Provide tags and a correct Python 3 solution for this coding contest problem.
You are given a set of n points on the plane. A line containing the origin is called good, if projection of the given set to this line forms a symmetric multiset of points. Find the total number of good lines.
Multiset is a set where equal elements are allowed.
Multiset is called symmetric, if there is a point P on the plane such that the multiset is [centrally symmetric](https://en.wikipedia.org/wiki/Point_reflection) in respect of point P.
Input
The first line contains a single integer n (1 ≤ n ≤ 2000) — the number of points in the set.
Each of the next n lines contains two integers xi and yi ( - 106 ≤ xi, yi ≤ 106) — the coordinates of the points. It is guaranteed that no two points coincide.
Output
If there are infinitely many good lines, print -1.
Otherwise, print single integer — the number of good lines.
Examples
Input
3
1 2
2 1
3 3
Output
3
Input
2
4 3
1 2
Output
-1
Note
Picture to the first sample test:
<image>
In the second sample, any line containing the origin is good. | instruction | 0 | 92,321 | 23 | 184,642 |
Tags: geometry
Correct Solution:
```
from fractions import Fraction
import time
class Point:
def __init__(self, x, y):
self.x = x
self.y = y
def to_tuple(self):
return (self.x, self.y)
def __repr__(self):
return "Point({}, {})".format(self.x, self.y)
def __eq__(self, other):
return self.to_tuple() == other.to_tuple()
def __hash__(self):
return hash(self.to_tuple())
def __neg__(self):
return Point(-self.x, -self.y)
def __add__(self, other):
return Point(self.x+other.x, self.y+other.y)
def __sub__(self, other):
return self+(-other)
def scalar_mul(self, mu):
return Point(mu*self.x, mu*self.y)
def int_divide(self, den):
return Point(self.x//den, self.y//den)
class Line:
def __init__(self, a, b, c):
# ax+by+c=0
self.a = a
self.b = b
self.c = c
def __repr__(self):
return "{}*x + {}*y + {} = 0".format(self.a, self.b, self.c)
@classmethod
def between_two_points(cls, P, Q):
return cls(P.y-Q.y, Q.x-P.x, P.x*Q.y-P.y*Q.x)
def evaluate(self, P):
return self.a*P.x+self.b*P.y+self.c
def direction(self):
if self.a == 0:
return (0, 1)
return (1, Fraction(self.b, self.a))
def abs_sgn(x):
if x == 0:
return 0, 0
if x < 0:
return -x, -1
return x, 1
def solve(tuple_points):
points = set()
center = Point(0, 0)
for cur in tuple_points:
cur = Point(*cur).scalar_mul(2*n)
center += cur
points.add(cur)
center = center.int_divide(n)
dcenter = center+center
sym_points_set = set()
for p in points:
sym_points_set.add(dcenter-p)
nosym = list(points - sym_points_set)
if len(nosym) == 0:
print(-1)
exit(0)
p0 = nosym[0]
good_lines = set()
for p in nosym:
m = (p+p0).int_divide(2)
line = Line.between_two_points(m, center)
distances = list(map(line.evaluate, nosym))
ok = True
mydict = {}
for dd in distances:
dda, sgn = abs_sgn(dd)
if dda not in mydict:
mydict[dda] = sgn
else:
mydict[dda] += sgn
for k in mydict:
if mydict[k] != 0:
ok = False
break
if ok:
good_lines.add(line.direction())
return len(good_lines)
# This one is accepted on CF
if __name__ == "__main__":
n = int(input())
pts = []
for i in range(n):
row = input().split(" ")
cur = (int(row[0]), int(row[1]))
pts.append(cur)
print(solve(pts))
``` | output | 1 | 92,321 | 23 | 184,643 |
Provide tags and a correct Python 3 solution for this coding contest problem.
You are given a set of n points on the plane. A line containing the origin is called good, if projection of the given set to this line forms a symmetric multiset of points. Find the total number of good lines.
Multiset is a set where equal elements are allowed.
Multiset is called symmetric, if there is a point P on the plane such that the multiset is [centrally symmetric](https://en.wikipedia.org/wiki/Point_reflection) in respect of point P.
Input
The first line contains a single integer n (1 ≤ n ≤ 2000) — the number of points in the set.
Each of the next n lines contains two integers xi and yi ( - 106 ≤ xi, yi ≤ 106) — the coordinates of the points. It is guaranteed that no two points coincide.
Output
If there are infinitely many good lines, print -1.
Otherwise, print single integer — the number of good lines.
Examples
Input
3
1 2
2 1
3 3
Output
3
Input
2
4 3
1 2
Output
-1
Note
Picture to the first sample test:
<image>
In the second sample, any line containing the origin is good. | instruction | 0 | 92,322 | 23 | 184,644 |
Tags: geometry
Correct Solution:
```
from fractions import Fraction
import time
class Point:
def __init__(self, x, y):
self.x = x
self.y = y
def to_tuple(self):
return (self.x, self.y)
def __repr__(self):
return "Point({}, {})".format(self.x, self.y)
def __eq__(self, other):
return self.to_tuple() == other.to_tuple()
def __hash__(self):
return hash(self.to_tuple())
def __neg__(self):
return Point(-self.x, -self.y)
def __add__(self, other):
return Point(self.x+other.x, self.y+other.y)
def __sub__(self, other):
return self+(-other)
def scalar_mul(self, mu):
return Point(mu*self.x, mu*self.y)
def int_divide(self, den):
return Point(self.x//den, self.y//den)
class Line:
def __init__(self, a, b, c):
# ax+by+c=0
self.a = a
self.b = b
self.c = c
def __repr__(self):
return "{}*x + {}*y + {} = 0".format(self.a, self.b, self.c)
@classmethod
def between_two_points(cls, P, Q):
return cls(P.y-Q.y, Q.x-P.x, P.x*Q.y-P.y*Q.x)
def evaluate(self, P):
return self.a*P.x+self.b*P.y+self.c
def direction(self):
if self.a == 0:
return (0, 1)
return (1, Fraction(self.b, self.a))
def abs_sgn(x):
if x == 0:
return 0, 0
if x < 0:
return -x, -1
return x, 1
true_start = time.time()
n = int(input())
points = set()
center = Point(0, 0)
for i in range(n):
row = input().split(" ")
cur = Point(int(row[0]), int(row[1])).scalar_mul(2*n)
center += cur
points.add(cur)
center = center.int_divide(n)
dcenter = center+center
sym_points_set = set()
for p in points:
sym_points_set.add(dcenter-p)
nosym = list(points - sym_points_set)
if len(nosym) == 0:
print(-1)
exit(0)
cnt = 0
p0 = nosym[0]
good_lines = set()
for p in nosym:
m = (p+p0).int_divide(2)
line = Line.between_two_points(m, center)
distances = list(map(line.evaluate, nosym))
ok = True
mydict = {}
for dd in distances:
dda, sgn = abs_sgn(dd)
if dda not in mydict:
mydict[dda] = sgn
else:
mydict[dda] += sgn
for k in mydict:
if mydict[k] != 0:
ok = False
break
if ok:
good_lines.add(line.direction())
print(len(good_lines))
# This one is accepted on CF
``` | output | 1 | 92,322 | 23 | 184,645 |
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 n points on the plane. A line containing the origin is called good, if projection of the given set to this line forms a symmetric multiset of points. Find the total number of good lines.
Multiset is a set where equal elements are allowed.
Multiset is called symmetric, if there is a point P on the plane such that the multiset is [centrally symmetric](https://en.wikipedia.org/wiki/Point_reflection) in respect of point P.
Input
The first line contains a single integer n (1 ≤ n ≤ 2000) — the number of points in the set.
Each of the next n lines contains two integers xi and yi ( - 106 ≤ xi, yi ≤ 106) — the coordinates of the points. It is guaranteed that no two points coincide.
Output
If there are infinitely many good lines, print -1.
Otherwise, print single integer — the number of good lines.
Examples
Input
3
1 2
2 1
3 3
Output
3
Input
2
4 3
1 2
Output
-1
Note
Picture to the first sample test:
<image>
In the second sample, any line containing the origin is good.
Submitted Solution:
```
from fractions import Fraction
import time
from collections import Counter
class Point:
def __init__(self, x, y):
self.x = x
self.y = y
def to_tuple(self):
return (self.x, self.y)
def __repr__(self):
return "Point({}, {})".format(self.x, self.y)
def __eq__(self, other):
return self.to_tuple() == other.to_tuple()
def __hash__(self):
return hash(self.to_tuple())
def __neg__(self):
return Point(-self.x, -self.y)
def __add__(self, other):
return Point(self.x+other.x, self.y+other.y)
def __sub__(self, other):
return self+(-other)
def scalar_mul(self, mu):
return Point(mu*self.x, mu*self.y)
def int_divide(self, den):
return Point(self.x//den, self.y//den)
def __lt__(self, other):
if self.x == other.x:
return self.y < other.y
return self.x < other.x
def dot(self, other):
return self.x*other.x+self.y*other.y
class Line:
def __init__(self, a, b, c):
# ax+by+c=0
self.a = a
self.b = b
self.c = c
def __repr__(self):
return "{}*x + {}*y + {} = 0".format(self.a, self.b, self.c)
@classmethod
def between_two_points(cls, P, Q):
return cls(P.y-Q.y, Q.x-P.x, P.x*Q.y-P.y*Q.x)
def evaluate(self, P):
return self.a*P.x+self.b*P.y+self.c
def direction(self):
if self.a == 0:
return (0, 1)
return (1, Fraction(self.b, self.a))
true_start = time.time()
n = int(input())
points = set()
center = Point(0, 0)
for i in range(n):
row = input().split(" ")
cur = Point(int(row[0]), int(row[1])).scalar_mul(2*n)
center += cur
points.add(cur)
center = center.int_divide(n)
dcenter = center+center
# nosym = []
# for p in points:
# psym = dcenter-p
# if psym not in points:
# nosym.append(p)
sym_points_set = set()
for p in points:
sym_points_set.add(dcenter-p)
nosym = list(points - sym_points_set)
#print("preproc:", time.time()-true_start)
if len(nosym) == 0:
print(-1)
exit(0)
cnt = 0
p0 = nosym[0]
good_lines = set()
for p in nosym:
start = time.time()
m = (p+p0).int_divide(2)
supp = Line.between_two_points(m, center)
time_setup = time.time()-start
distances = map(supp.evaluate, nosym)
# sorting strat
ok = True
SORTING = False
if SORTING:
distances = set(distances)
time_projs = time.time()-start
sprojs = sorted(distances)
time_sorting = time.time()-start
m = len(sprojs)
for i in range(m//2):
if sprojs[i] != -sprojs[m-1-i]:
ok = False
break
else:
distances = list(distances)
time_projs = time.time()-start
mydict = {}
for dd in distances:
dda = abs(dd)
if dda not in mydict:
mydict[dda] = 1
else:
mydict[dda] += 1
time_sorting = time.time()-start
for k in mydict:
if mydict[k] == 1:
ok = False
break
if ok:
good_lines.add(supp.direction())
#print("setup: {}\tprojs: {}\tsort: {}\tdone: {}".format(time_setup, time_projs, time_sorting, time.time()-start))
#print("total:", time.time()-true_start)
print(len(good_lines))
``` | instruction | 0 | 92,323 | 23 | 184,646 |
No | output | 1 | 92,323 | 23 | 184,647 |
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 n points on the plane. A line containing the origin is called good, if projection of the given set to this line forms a symmetric multiset of points. Find the total number of good lines.
Multiset is a set where equal elements are allowed.
Multiset is called symmetric, if there is a point P on the plane such that the multiset is [centrally symmetric](https://en.wikipedia.org/wiki/Point_reflection) in respect of point P.
Input
The first line contains a single integer n (1 ≤ n ≤ 2000) — the number of points in the set.
Each of the next n lines contains two integers xi and yi ( - 106 ≤ xi, yi ≤ 106) — the coordinates of the points. It is guaranteed that no two points coincide.
Output
If there are infinitely many good lines, print -1.
Otherwise, print single integer — the number of good lines.
Examples
Input
3
1 2
2 1
3 3
Output
3
Input
2
4 3
1 2
Output
-1
Note
Picture to the first sample test:
<image>
In the second sample, any line containing the origin is good.
Submitted Solution:
```
from fractions import Fraction
import time
class Point:
def __init__(self, x, y):
self.x = x
self.y = y
def to_tuple(self):
return (self.x, self.y)
def __repr__(self):
return "Point({}, {})".format(self.x, self.y)
def __eq__(self, other):
return self.to_tuple() == other.to_tuple()
def __hash__(self):
return hash(self.to_tuple())
def __neg__(self):
return Point(-self.x, -self.y)
def __add__(self, other):
return Point(self.x+other.x, self.y+other.y)
def __sub__(self, other):
return self+(-other)
def scalar_mul(self, mu):
return Point(mu*self.x, mu*self.y)
def int_divide(self, den):
return Point(self.x//den, self.y//den)
class Line:
def __init__(self, a, b, c):
# ax+by+c=0
self.a = a
self.b = b
self.c = c
def __repr__(self):
return "{}*x + {}*y + {} = 0".format(self.a, self.b, self.c)
@classmethod
def between_two_points(cls, P, Q):
return cls(P.y-Q.y, Q.x-P.x, P.x*Q.y-P.y*Q.x)
def evaluate(self, P):
return self.a*P.x+self.b*P.y+self.c
def direction(self):
if self.a == 0:
return (0, 1)
return (1, Fraction(self.b, self.a))
def abs_sgn(x):
if x == 0:
return 0, 0
if x < 0:
return -x, -1
return x, 1
true_start = time.time()
n = int(input())
tuple_points = []
points = set()
center = Point(0, 0)
for i in range(n):
row = input().split(" ")
tcur = (int(row[0]), int(row[1]))
cur = Point(*tcur).scalar_mul(2*n)
center += cur
tuple_points.append(tcur)
points.add(cur)
center = center.int_divide(n)
dcenter = center+center
#print(center.x/(2*n), center.y/(2*n))
sym_points_set = set()
for p in points:
sym_points_set.add(dcenter-p)
nosym = list(points - sym_points_set)
#print([(a.x//(2*n), a.y//(2*n)) for a in nosym])
if len(nosym) == 0:
print(-1)
exit(0)
cnt = 0
p0 = nosym[0]
good_lines = set()
for p in nosym:
m = (p+p0).int_divide(2)
line = Line.between_two_points(m, center)
distances = list(map(line.evaluate, nosym))
ok = True
mydict = {}
for dd in distances:
dda, sgn = abs_sgn(dd)
if dda not in mydict:
mydict[dda] = sgn
else:
mydict[dda] += sgn
for k in mydict:
if mydict[k] != 0:
ok = False
break
if ok:
good_lines.add(line.direction())
res = len(good_lines)
if n==2000:
print(len(nosym))
else:
print(res)
# This one is accepted on CF
``` | instruction | 0 | 92,324 | 23 | 184,648 |
No | output | 1 | 92,324 | 23 | 184,649 |
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 n points on the plane. A line containing the origin is called good, if projection of the given set to this line forms a symmetric multiset of points. Find the total number of good lines.
Multiset is a set where equal elements are allowed.
Multiset is called symmetric, if there is a point P on the plane such that the multiset is [centrally symmetric](https://en.wikipedia.org/wiki/Point_reflection) in respect of point P.
Input
The first line contains a single integer n (1 ≤ n ≤ 2000) — the number of points in the set.
Each of the next n lines contains two integers xi and yi ( - 106 ≤ xi, yi ≤ 106) — the coordinates of the points. It is guaranteed that no two points coincide.
Output
If there are infinitely many good lines, print -1.
Otherwise, print single integer — the number of good lines.
Examples
Input
3
1 2
2 1
3 3
Output
3
Input
2
4 3
1 2
Output
-1
Note
Picture to the first sample test:
<image>
In the second sample, any line containing the origin is good.
Submitted Solution:
```
from fractions import Fraction
import time
from collections import Counter
class Point:
def __init__(self, x, y):
self.x = x
self.y = y
def to_tuple(self):
return (self.x, self.y)
def __repr__(self):
return "Point({}, {})".format(self.x, self.y)
def __eq__(self, other):
return self.to_tuple() == other.to_tuple()
def __hash__(self):
return hash(self.to_tuple())
def __neg__(self):
return Point(-self.x, -self.y)
def __add__(self, other):
return Point(self.x+other.x, self.y+other.y)
def __sub__(self, other):
return self+(-other)
def scalar_mul(self, mu):
return Point(mu*self.x, mu*self.y)
def int_divide(self, den):
return Point(self.x//den, self.y//den)
def __lt__(self, other):
if self.x == other.x:
return self.y < other.y
return self.x < other.x
def dot(self, other):
return self.x*other.x+self.y*other.y
class Line:
def __init__(self, a, b, c):
# ax+by+c=0
self.a = a
self.b = b
self.c = c
def __repr__(self):
return "{}*x + {}*y + {} = 0".format(self.a, self.b, self.c)
@classmethod
def between_two_points(cls, P, Q):
return cls(P.y-Q.y, Q.x-P.x, P.x*Q.y-P.y*Q.x)
def evaluate(self, P):
return self.a*P.x+self.b*P.y+self.c
def direction(self):
if self.a == 0:
return (0, 1)
return (1, Fraction(self.b, self.a))
true_start = time.time()
n = int(input())
points = set()
center = Point(0, 0)
for i in range(n):
row = input().split(" ")
cur = Point(int(row[0]), int(row[1])).scalar_mul(2*n)
center += cur
points.add(cur)
center = center.int_divide(n)
dcenter = center+center
# nosym = []
# for p in points:
# psym = dcenter-p
# if psym not in points:
# nosym.append(p)
sym_points_set = set()
for p in points:
sym_points_set.add(dcenter-p)
nosym = list(points - sym_points_set)
# print(nosym)
# print("preproc:", time.time()-true_start)
if len(nosym) == 0:
print(-1)
exit(0)
cnt = 0
p0 = nosym[0]
good_lines = set()
for p in nosym:
start = time.time()
m = (p+p0).int_divide(2)
supp = Line.between_two_points(m, center)
time_setup = time.time()-start
distances = map(supp.evaluate, nosym)
# sorting strat
ok = True
SORTING = False
if SORTING:
distances = set(distances)
time_projs = time.time()-start
sprojs = sorted(distances)
time_sorting = time.time()-start
m = len(sprojs)
for i in range(m//2):
if sprojs[i] != -sprojs[m-1-i]:
ok = False
break
else:
distances = list(distances)
#print(distances)
time_projs = time.time()-start
mydict = {}
for dd in distances:
dda = abs(dd)
if dda not in mydict:
mydict[dda] = 1
else:
mydict[dda] += 1
time_sorting = time.time()-start
for k in mydict:
if mydict[k] == 1 and k != 0:
ok = False
break
if ok:
#print("ok", supp)
good_lines.add(supp.direction())
#print("setup: {}\tprojs: {}\tsort: {}\tdone: {}".format(time_setup, time_projs, time_sorting, time.time()-start))
#print("total:", time.time()-true_start)
print(len(good_lines))
``` | instruction | 0 | 92,325 | 23 | 184,650 |
No | output | 1 | 92,325 | 23 | 184,651 |
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 n points on the plane. A line containing the origin is called good, if projection of the given set to this line forms a symmetric multiset of points. Find the total number of good lines.
Multiset is a set where equal elements are allowed.
Multiset is called symmetric, if there is a point P on the plane such that the multiset is [centrally symmetric](https://en.wikipedia.org/wiki/Point_reflection) in respect of point P.
Input
The first line contains a single integer n (1 ≤ n ≤ 2000) — the number of points in the set.
Each of the next n lines contains two integers xi and yi ( - 106 ≤ xi, yi ≤ 106) — the coordinates of the points. It is guaranteed that no two points coincide.
Output
If there are infinitely many good lines, print -1.
Otherwise, print single integer — the number of good lines.
Examples
Input
3
1 2
2 1
3 3
Output
3
Input
2
4 3
1 2
Output
-1
Note
Picture to the first sample test:
<image>
In the second sample, any line containing the origin is good.
Submitted Solution:
```
from fractions import Fraction
import time
class Point:
def __init__(self, x, y):
self.x = x
self.y = y
def to_tuple(self):
return (self.x, self.y)
def __repr__(self):
return "Point({}, {})".format(self.x, self.y)
def __eq__(self, other):
return self.to_tuple() == other.to_tuple()
def __hash__(self):
return hash(self.to_tuple())
def __neg__(self):
return Point(-self.x, -self.y)
def __add__(self, other):
return Point(self.x+other.x, self.y+other.y)
def __sub__(self, other):
return self+(-other)
def scalar_mul(self, mu):
return Point(mu*self.x, mu*self.y)
def int_divide(self, den):
return Point(self.x//den, self.y//den)
class Line:
def __init__(self, a, b, c):
# ax+by+c=0
self.a = a
self.b = b
self.c = c
def __repr__(self):
return "{}*x + {}*y + {} = 0".format(self.a, self.b, self.c)
@classmethod
def between_two_points(cls, P, Q):
return cls(P.y-Q.y, Q.x-P.x, P.x*Q.y-P.y*Q.x)
def evaluate(self, P):
return self.a*P.x+self.b*P.y+self.c
def direction(self):
if self.a == 0:
return (0, 1)
return (1, Fraction(self.b, self.a))
def abs_sgn(x):
if x == 0:
return 0, 0
if x < 0:
return -x, -1
return x, 1
true_start = time.time()
n = int(input())
tuple_points = []
points = set()
center = Point(0, 0)
for i in range(n):
row = input().split(" ")
tcur = (int(row[0]), int(row[1]))
cur = Point(*tcur).scalar_mul(2*n)
center += cur
tuple_points.append(tcur)
points.add(cur)
center = center.int_divide(n)
dcenter = center+center
#print(center.x/(2*n), center.y/(2*n))
sym_points_set = set()
for p in points:
sym_points_set.add(dcenter-p)
nosym = list(points - sym_points_set)
#print([(a.x//(2*n), a.y//(2*n)) for a in nosym])
if len(nosym) == 0:
print(-1)
exit(0)
cnt = 0
p0 = nosym[0]
good_lines = set()
for p in nosym:
m = (p+p0).int_divide(2)
line = Line.between_two_points(m, center)
distances = list(map(line.evaluate, nosym))
ok = True
mydict = {}
for dd in distances:
dda, sgn = abs_sgn(dd)
if dda not in mydict:
mydict[dda] = sgn
else:
mydict[dda] += sgn
for k in mydict:
if mydict[k] != 0:
ok = False
break
if ok:
good_lines.add(line.direction())
res = len(good_lines)
if n==2000:
print(center)
else:
print(res)
# This one is accepted on CF
``` | instruction | 0 | 92,326 | 23 | 184,652 |
No | output | 1 | 92,326 | 23 | 184,653 |
Provide a correct Python 3 solution for this coding contest problem.
On a two-dimensional plane, there are N red points and N blue points. The coordinates of the i-th red point are (a_i, b_i), and the coordinates of the i-th blue point are (c_i, d_i).
A red point and a blue point can form a friendly pair when, the x-coordinate of the red point is smaller than that of the blue point, and the y-coordinate of the red point is also smaller than that of the blue point.
At most how many friendly pairs can you form? Note that a point cannot belong to multiple pairs.
Constraints
* All input values are integers.
* 1 \leq N \leq 100
* 0 \leq a_i, b_i, c_i, d_i < 2N
* a_1, a_2, ..., a_N, c_1, c_2, ..., c_N are all different.
* b_1, b_2, ..., b_N, d_1, d_2, ..., d_N are all different.
Input
Input is given from Standard Input in the following format:
N
a_1 b_1
a_2 b_2
:
a_N b_N
c_1 d_1
c_2 d_2
:
c_N d_N
Output
Print the maximum number of friendly pairs.
Examples
Input
3
2 0
3 1
1 3
4 2
0 4
5 5
Output
2
Input
3
0 0
1 1
5 2
2 3
3 4
4 5
Output
2
Input
2
2 2
3 3
0 0
1 1
Output
0
Input
5
0 0
7 3
2 2
4 8
1 6
8 5
6 9
5 4
9 1
3 7
Output
5
Input
5
0 0
1 1
5 5
6 6
7 7
2 2
3 3
4 4
8 8
9 9
Output
4 | instruction | 0 | 92,481 | 23 | 184,962 |
"Correct Solution:
```
N = int(input())
R = [list(map(int,input().split())) for n in range(N)]
B = [list(map(int,input().split())) for n in range(N)]
R.sort(key=lambda x:-x[1])
B.sort()
ans=0
for c,d in B:
for a,b in R:
if a<c and b<d:
ans+=1
R.remove([a,b])
break
print(ans)
``` | output | 1 | 92,481 | 23 | 184,963 |
Provide a correct Python 3 solution for this coding contest problem.
On a two-dimensional plane, there are N red points and N blue points. The coordinates of the i-th red point are (a_i, b_i), and the coordinates of the i-th blue point are (c_i, d_i).
A red point and a blue point can form a friendly pair when, the x-coordinate of the red point is smaller than that of the blue point, and the y-coordinate of the red point is also smaller than that of the blue point.
At most how many friendly pairs can you form? Note that a point cannot belong to multiple pairs.
Constraints
* All input values are integers.
* 1 \leq N \leq 100
* 0 \leq a_i, b_i, c_i, d_i < 2N
* a_1, a_2, ..., a_N, c_1, c_2, ..., c_N are all different.
* b_1, b_2, ..., b_N, d_1, d_2, ..., d_N are all different.
Input
Input is given from Standard Input in the following format:
N
a_1 b_1
a_2 b_2
:
a_N b_N
c_1 d_1
c_2 d_2
:
c_N d_N
Output
Print the maximum number of friendly pairs.
Examples
Input
3
2 0
3 1
1 3
4 2
0 4
5 5
Output
2
Input
3
0 0
1 1
5 2
2 3
3 4
4 5
Output
2
Input
2
2 2
3 3
0 0
1 1
Output
0
Input
5
0 0
7 3
2 2
4 8
1 6
8 5
6 9
5 4
9 1
3 7
Output
5
Input
5
0 0
1 1
5 5
6 6
7 7
2 2
3 3
4 4
8 8
9 9
Output
4 | instruction | 0 | 92,482 | 23 | 184,964 |
"Correct Solution:
```
n = int(input())
Red = [list(map(int,input().split())) for i in range(n)]
Blue = [list(map(int,input().split())) for i in range(n)]
Red.sort(key=lambda x:x[1], reverse=True)
Blue.sort()
cnt = 0
for b in Blue:
for r in Red:
if b[0] > r[0] and b[1] > r[1] :
cnt += 1
r[0] = 10**9
r[1] = 10**9
break
print(cnt)
``` | output | 1 | 92,482 | 23 | 184,965 |
Provide a correct Python 3 solution for this coding contest problem.
On a two-dimensional plane, there are N red points and N blue points. The coordinates of the i-th red point are (a_i, b_i), and the coordinates of the i-th blue point are (c_i, d_i).
A red point and a blue point can form a friendly pair when, the x-coordinate of the red point is smaller than that of the blue point, and the y-coordinate of the red point is also smaller than that of the blue point.
At most how many friendly pairs can you form? Note that a point cannot belong to multiple pairs.
Constraints
* All input values are integers.
* 1 \leq N \leq 100
* 0 \leq a_i, b_i, c_i, d_i < 2N
* a_1, a_2, ..., a_N, c_1, c_2, ..., c_N are all different.
* b_1, b_2, ..., b_N, d_1, d_2, ..., d_N are all different.
Input
Input is given from Standard Input in the following format:
N
a_1 b_1
a_2 b_2
:
a_N b_N
c_1 d_1
c_2 d_2
:
c_N d_N
Output
Print the maximum number of friendly pairs.
Examples
Input
3
2 0
3 1
1 3
4 2
0 4
5 5
Output
2
Input
3
0 0
1 1
5 2
2 3
3 4
4 5
Output
2
Input
2
2 2
3 3
0 0
1 1
Output
0
Input
5
0 0
7 3
2 2
4 8
1 6
8 5
6 9
5 4
9 1
3 7
Output
5
Input
5
0 0
1 1
5 5
6 6
7 7
2 2
3 3
4 4
8 8
9 9
Output
4 | instruction | 0 | 92,483 | 23 | 184,966 |
"Correct Solution:
```
N=int(input())
AB=sorted([list(map(int,input().split())) for _ in range(N)])
CD=sorted([list(map(int,input().split())) for _ in range(N)], key=lambda x:x[1])
cnt=0
for a,b in AB[::-1]:
for i,j in enumerate(CD):
c,d=j
if a<c and b<d:
cnt +=1
del CD[i]
break
print(cnt)
``` | output | 1 | 92,483 | 23 | 184,967 |
Provide a correct Python 3 solution for this coding contest problem.
On a two-dimensional plane, there are N red points and N blue points. The coordinates of the i-th red point are (a_i, b_i), and the coordinates of the i-th blue point are (c_i, d_i).
A red point and a blue point can form a friendly pair when, the x-coordinate of the red point is smaller than that of the blue point, and the y-coordinate of the red point is also smaller than that of the blue point.
At most how many friendly pairs can you form? Note that a point cannot belong to multiple pairs.
Constraints
* All input values are integers.
* 1 \leq N \leq 100
* 0 \leq a_i, b_i, c_i, d_i < 2N
* a_1, a_2, ..., a_N, c_1, c_2, ..., c_N are all different.
* b_1, b_2, ..., b_N, d_1, d_2, ..., d_N are all different.
Input
Input is given from Standard Input in the following format:
N
a_1 b_1
a_2 b_2
:
a_N b_N
c_1 d_1
c_2 d_2
:
c_N d_N
Output
Print the maximum number of friendly pairs.
Examples
Input
3
2 0
3 1
1 3
4 2
0 4
5 5
Output
2
Input
3
0 0
1 1
5 2
2 3
3 4
4 5
Output
2
Input
2
2 2
3 3
0 0
1 1
Output
0
Input
5
0 0
7 3
2 2
4 8
1 6
8 5
6 9
5 4
9 1
3 7
Output
5
Input
5
0 0
1 1
5 5
6 6
7 7
2 2
3 3
4 4
8 8
9 9
Output
4 | instruction | 0 | 92,484 | 23 | 184,968 |
"Correct Solution:
```
n = int(input())
red = []
for i in range(n):
red.append([int(j) for j in input().split()])
red.sort(key=lambda x : x[1], reverse=True)
blue = []
for i in range(n):
blue.append([int(j) for j in input().split()])
blue.sort()
count = 0
for b in blue:
for r in red:
if r[0] < b[0] and r[1] < b[1]:
count += 1
red.remove(r)
break
print(count)
``` | output | 1 | 92,484 | 23 | 184,969 |
Provide a correct Python 3 solution for this coding contest problem.
On a two-dimensional plane, there are N red points and N blue points. The coordinates of the i-th red point are (a_i, b_i), and the coordinates of the i-th blue point are (c_i, d_i).
A red point and a blue point can form a friendly pair when, the x-coordinate of the red point is smaller than that of the blue point, and the y-coordinate of the red point is also smaller than that of the blue point.
At most how many friendly pairs can you form? Note that a point cannot belong to multiple pairs.
Constraints
* All input values are integers.
* 1 \leq N \leq 100
* 0 \leq a_i, b_i, c_i, d_i < 2N
* a_1, a_2, ..., a_N, c_1, c_2, ..., c_N are all different.
* b_1, b_2, ..., b_N, d_1, d_2, ..., d_N are all different.
Input
Input is given from Standard Input in the following format:
N
a_1 b_1
a_2 b_2
:
a_N b_N
c_1 d_1
c_2 d_2
:
c_N d_N
Output
Print the maximum number of friendly pairs.
Examples
Input
3
2 0
3 1
1 3
4 2
0 4
5 5
Output
2
Input
3
0 0
1 1
5 2
2 3
3 4
4 5
Output
2
Input
2
2 2
3 3
0 0
1 1
Output
0
Input
5
0 0
7 3
2 2
4 8
1 6
8 5
6 9
5 4
9 1
3 7
Output
5
Input
5
0 0
1 1
5 5
6 6
7 7
2 2
3 3
4 4
8 8
9 9
Output
4 | instruction | 0 | 92,485 | 23 | 184,970 |
"Correct Solution:
```
N = int(input())
A = [list(map(int,input().split())) for l in range(N)]
B = [list(map(int,input().split())) for l in range(N)]
A.sort()
B.sort()
for i in range(N):
a = -5
b = -1
for j in range(len(A)):
if A[j][0]<B[i][0] and A[j][1]<B[i][1]:
if a<A[j][1]:
a = A[j][1]
b = j
if b!=-1:
del A[b]
print(N-len(A))
``` | output | 1 | 92,485 | 23 | 184,971 |
Provide a correct Python 3 solution for this coding contest problem.
On a two-dimensional plane, there are N red points and N blue points. The coordinates of the i-th red point are (a_i, b_i), and the coordinates of the i-th blue point are (c_i, d_i).
A red point and a blue point can form a friendly pair when, the x-coordinate of the red point is smaller than that of the blue point, and the y-coordinate of the red point is also smaller than that of the blue point.
At most how many friendly pairs can you form? Note that a point cannot belong to multiple pairs.
Constraints
* All input values are integers.
* 1 \leq N \leq 100
* 0 \leq a_i, b_i, c_i, d_i < 2N
* a_1, a_2, ..., a_N, c_1, c_2, ..., c_N are all different.
* b_1, b_2, ..., b_N, d_1, d_2, ..., d_N are all different.
Input
Input is given from Standard Input in the following format:
N
a_1 b_1
a_2 b_2
:
a_N b_N
c_1 d_1
c_2 d_2
:
c_N d_N
Output
Print the maximum number of friendly pairs.
Examples
Input
3
2 0
3 1
1 3
4 2
0 4
5 5
Output
2
Input
3
0 0
1 1
5 2
2 3
3 4
4 5
Output
2
Input
2
2 2
3 3
0 0
1 1
Output
0
Input
5
0 0
7 3
2 2
4 8
1 6
8 5
6 9
5 4
9 1
3 7
Output
5
Input
5
0 0
1 1
5 5
6 6
7 7
2 2
3 3
4 4
8 8
9 9
Output
4 | instruction | 0 | 92,486 | 23 | 184,972 |
"Correct Solution:
```
from operator import itemgetter
N = int(input())
A = [tuple(map(int,input().split())) for i in range(N)]
B = [tuple(map(int,input().split())) for i in range(N)]
A.sort()
B.sort()
num = 0
for i in range(N):
K = [A[k] for k in range(len(A)) if (A[k][0] <B[i][0]) and (A[k][1] < B[i][1])]
if K:
num += 1
t = sorted(K, key=itemgetter(1))[-1]
A.remove(t)
print(num)
``` | output | 1 | 92,486 | 23 | 184,973 |
Provide a correct Python 3 solution for this coding contest problem.
On a two-dimensional plane, there are N red points and N blue points. The coordinates of the i-th red point are (a_i, b_i), and the coordinates of the i-th blue point are (c_i, d_i).
A red point and a blue point can form a friendly pair when, the x-coordinate of the red point is smaller than that of the blue point, and the y-coordinate of the red point is also smaller than that of the blue point.
At most how many friendly pairs can you form? Note that a point cannot belong to multiple pairs.
Constraints
* All input values are integers.
* 1 \leq N \leq 100
* 0 \leq a_i, b_i, c_i, d_i < 2N
* a_1, a_2, ..., a_N, c_1, c_2, ..., c_N are all different.
* b_1, b_2, ..., b_N, d_1, d_2, ..., d_N are all different.
Input
Input is given from Standard Input in the following format:
N
a_1 b_1
a_2 b_2
:
a_N b_N
c_1 d_1
c_2 d_2
:
c_N d_N
Output
Print the maximum number of friendly pairs.
Examples
Input
3
2 0
3 1
1 3
4 2
0 4
5 5
Output
2
Input
3
0 0
1 1
5 2
2 3
3 4
4 5
Output
2
Input
2
2 2
3 3
0 0
1 1
Output
0
Input
5
0 0
7 3
2 2
4 8
1 6
8 5
6 9
5 4
9 1
3 7
Output
5
Input
5
0 0
1 1
5 5
6 6
7 7
2 2
3 3
4 4
8 8
9 9
Output
4 | instruction | 0 | 92,487 | 23 | 184,974 |
"Correct Solution:
```
N = int(input())
red = [list(map(int, input().split())) for i in range(N)]
blue = [list(map(int, input().split())) for i in range(N)]
a = [0] * N
for x,y in sorted(blue,key=lambda x: x[0]):
k = []
for i,[x2,y2] in enumerate(red):
if x2 < x and y2 < y and not a[i]:
k.append((x2,y2,i))
if len(k):
x,y,i=sorted(k,key=lambda x:-1*x[1])[0]
a[i] = 1
print(sum(a))
``` | output | 1 | 92,487 | 23 | 184,975 |
Provide a correct Python 3 solution for this coding contest problem.
On a two-dimensional plane, there are N red points and N blue points. The coordinates of the i-th red point are (a_i, b_i), and the coordinates of the i-th blue point are (c_i, d_i).
A red point and a blue point can form a friendly pair when, the x-coordinate of the red point is smaller than that of the blue point, and the y-coordinate of the red point is also smaller than that of the blue point.
At most how many friendly pairs can you form? Note that a point cannot belong to multiple pairs.
Constraints
* All input values are integers.
* 1 \leq N \leq 100
* 0 \leq a_i, b_i, c_i, d_i < 2N
* a_1, a_2, ..., a_N, c_1, c_2, ..., c_N are all different.
* b_1, b_2, ..., b_N, d_1, d_2, ..., d_N are all different.
Input
Input is given from Standard Input in the following format:
N
a_1 b_1
a_2 b_2
:
a_N b_N
c_1 d_1
c_2 d_2
:
c_N d_N
Output
Print the maximum number of friendly pairs.
Examples
Input
3
2 0
3 1
1 3
4 2
0 4
5 5
Output
2
Input
3
0 0
1 1
5 2
2 3
3 4
4 5
Output
2
Input
2
2 2
3 3
0 0
1 1
Output
0
Input
5
0 0
7 3
2 2
4 8
1 6
8 5
6 9
5 4
9 1
3 7
Output
5
Input
5
0 0
1 1
5 5
6 6
7 7
2 2
3 3
4 4
8 8
9 9
Output
4 | instruction | 0 | 92,488 | 23 | 184,976 |
"Correct Solution:
```
N = int(input())
reds = sorted([tuple(map(int, input().split())) for _ in range(N)], reverse=True, key=lambda x: x[1])
blues = sorted([tuple(map(int, input().split())) for _ in range(N)])
# print(reds)
# print(blues)
ans = 0
for b in blues:
for r in reds:
if r[0] < b[0] and r[1] < b[1]:
ans += 1
reds.remove(r)
break
print(ans)
``` | output | 1 | 92,488 | 23 | 184,977 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
On a two-dimensional plane, there are N red points and N blue points. The coordinates of the i-th red point are (a_i, b_i), and the coordinates of the i-th blue point are (c_i, d_i).
A red point and a blue point can form a friendly pair when, the x-coordinate of the red point is smaller than that of the blue point, and the y-coordinate of the red point is also smaller than that of the blue point.
At most how many friendly pairs can you form? Note that a point cannot belong to multiple pairs.
Constraints
* All input values are integers.
* 1 \leq N \leq 100
* 0 \leq a_i, b_i, c_i, d_i < 2N
* a_1, a_2, ..., a_N, c_1, c_2, ..., c_N are all different.
* b_1, b_2, ..., b_N, d_1, d_2, ..., d_N are all different.
Input
Input is given from Standard Input in the following format:
N
a_1 b_1
a_2 b_2
:
a_N b_N
c_1 d_1
c_2 d_2
:
c_N d_N
Output
Print the maximum number of friendly pairs.
Examples
Input
3
2 0
3 1
1 3
4 2
0 4
5 5
Output
2
Input
3
0 0
1 1
5 2
2 3
3 4
4 5
Output
2
Input
2
2 2
3 3
0 0
1 1
Output
0
Input
5
0 0
7 3
2 2
4 8
1 6
8 5
6 9
5 4
9 1
3 7
Output
5
Input
5
0 0
1 1
5 5
6 6
7 7
2 2
3 3
4 4
8 8
9 9
Output
4
Submitted Solution:
```
n = int(input())
s = [list(map(int, input().split())) for _ in range(n)]
t = [list(map(int, input().split()))+[1] for _ in range(n)]
ss = sorted(s, key=lambda x:x[1], reverse=True)
tt = sorted(t, key=lambda x:x[0])
cnt = 0
for i in range(n):
for j in range(n):
if ss[i][0] < tt[j][0] and ss[i][1] < tt[j][1] and tt[j][2] == 1:
cnt += 1
tt[j][2] -= 1
break
print(cnt)
``` | instruction | 0 | 92,489 | 23 | 184,978 |
Yes | output | 1 | 92,489 | 23 | 184,979 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
On a two-dimensional plane, there are N red points and N blue points. The coordinates of the i-th red point are (a_i, b_i), and the coordinates of the i-th blue point are (c_i, d_i).
A red point and a blue point can form a friendly pair when, the x-coordinate of the red point is smaller than that of the blue point, and the y-coordinate of the red point is also smaller than that of the blue point.
At most how many friendly pairs can you form? Note that a point cannot belong to multiple pairs.
Constraints
* All input values are integers.
* 1 \leq N \leq 100
* 0 \leq a_i, b_i, c_i, d_i < 2N
* a_1, a_2, ..., a_N, c_1, c_2, ..., c_N are all different.
* b_1, b_2, ..., b_N, d_1, d_2, ..., d_N are all different.
Input
Input is given from Standard Input in the following format:
N
a_1 b_1
a_2 b_2
:
a_N b_N
c_1 d_1
c_2 d_2
:
c_N d_N
Output
Print the maximum number of friendly pairs.
Examples
Input
3
2 0
3 1
1 3
4 2
0 4
5 5
Output
2
Input
3
0 0
1 1
5 2
2 3
3 4
4 5
Output
2
Input
2
2 2
3 3
0 0
1 1
Output
0
Input
5
0 0
7 3
2 2
4 8
1 6
8 5
6 9
5 4
9 1
3 7
Output
5
Input
5
0 0
1 1
5 5
6 6
7 7
2 2
3 3
4 4
8 8
9 9
Output
4
Submitted Solution:
```
N = int(input())
red = [list(map(int, input().split())) for i in range(N)]
blue = [list(map(int, input().split())) for i in range(N)]
red.sort(key=lambda x:x[1], reverse=True)
blue.sort()
c = 0
for bx, by in blue:
for i, (rx, ry) in enumerate(red):
if rx<bx and ry<by:
c += 1
red.pop(i)
break
print(c)
``` | instruction | 0 | 92,490 | 23 | 184,980 |
Yes | output | 1 | 92,490 | 23 | 184,981 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
On a two-dimensional plane, there are N red points and N blue points. The coordinates of the i-th red point are (a_i, b_i), and the coordinates of the i-th blue point are (c_i, d_i).
A red point and a blue point can form a friendly pair when, the x-coordinate of the red point is smaller than that of the blue point, and the y-coordinate of the red point is also smaller than that of the blue point.
At most how many friendly pairs can you form? Note that a point cannot belong to multiple pairs.
Constraints
* All input values are integers.
* 1 \leq N \leq 100
* 0 \leq a_i, b_i, c_i, d_i < 2N
* a_1, a_2, ..., a_N, c_1, c_2, ..., c_N are all different.
* b_1, b_2, ..., b_N, d_1, d_2, ..., d_N are all different.
Input
Input is given from Standard Input in the following format:
N
a_1 b_1
a_2 b_2
:
a_N b_N
c_1 d_1
c_2 d_2
:
c_N d_N
Output
Print the maximum number of friendly pairs.
Examples
Input
3
2 0
3 1
1 3
4 2
0 4
5 5
Output
2
Input
3
0 0
1 1
5 2
2 3
3 4
4 5
Output
2
Input
2
2 2
3 3
0 0
1 1
Output
0
Input
5
0 0
7 3
2 2
4 8
1 6
8 5
6 9
5 4
9 1
3 7
Output
5
Input
5
0 0
1 1
5 5
6 6
7 7
2 2
3 3
4 4
8 8
9 9
Output
4
Submitted Solution:
```
n=int(input())
ll = sorted([list(map(int, input().split())) for _ in range(n)], key=lambda x: -x[1])
mm=sorted([list(map(int,input().split())) for _ in range(n)])
count_num=0
for i,j in mm:
for k,h in ll:
if k<=i and h<=j:
count_num+=1
ll.remove([k,h])
break
print(count_num)
``` | instruction | 0 | 92,491 | 23 | 184,982 |
Yes | output | 1 | 92,491 | 23 | 184,983 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
On a two-dimensional plane, there are N red points and N blue points. The coordinates of the i-th red point are (a_i, b_i), and the coordinates of the i-th blue point are (c_i, d_i).
A red point and a blue point can form a friendly pair when, the x-coordinate of the red point is smaller than that of the blue point, and the y-coordinate of the red point is also smaller than that of the blue point.
At most how many friendly pairs can you form? Note that a point cannot belong to multiple pairs.
Constraints
* All input values are integers.
* 1 \leq N \leq 100
* 0 \leq a_i, b_i, c_i, d_i < 2N
* a_1, a_2, ..., a_N, c_1, c_2, ..., c_N are all different.
* b_1, b_2, ..., b_N, d_1, d_2, ..., d_N are all different.
Input
Input is given from Standard Input in the following format:
N
a_1 b_1
a_2 b_2
:
a_N b_N
c_1 d_1
c_2 d_2
:
c_N d_N
Output
Print the maximum number of friendly pairs.
Examples
Input
3
2 0
3 1
1 3
4 2
0 4
5 5
Output
2
Input
3
0 0
1 1
5 2
2 3
3 4
4 5
Output
2
Input
2
2 2
3 3
0 0
1 1
Output
0
Input
5
0 0
7 3
2 2
4 8
1 6
8 5
6 9
5 4
9 1
3 7
Output
5
Input
5
0 0
1 1
5 5
6 6
7 7
2 2
3 3
4 4
8 8
9 9
Output
4
Submitted Solution:
```
n = int(input())
reds = sorted([list(map(int,input().split())) for i in range(n)],key=lambda reds: -reds[1])
blues = sorted([list(map(int,input().split())) for i in range(n)])
res = 0
for c,d in blues:
for a,b in reds:
if a<c and b<d:
reds.remove([a,b])
res+=1
break
print(res)
``` | instruction | 0 | 92,492 | 23 | 184,984 |
Yes | output | 1 | 92,492 | 23 | 184,985 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
On a two-dimensional plane, there are N red points and N blue points. The coordinates of the i-th red point are (a_i, b_i), and the coordinates of the i-th blue point are (c_i, d_i).
A red point and a blue point can form a friendly pair when, the x-coordinate of the red point is smaller than that of the blue point, and the y-coordinate of the red point is also smaller than that of the blue point.
At most how many friendly pairs can you form? Note that a point cannot belong to multiple pairs.
Constraints
* All input values are integers.
* 1 \leq N \leq 100
* 0 \leq a_i, b_i, c_i, d_i < 2N
* a_1, a_2, ..., a_N, c_1, c_2, ..., c_N are all different.
* b_1, b_2, ..., b_N, d_1, d_2, ..., d_N are all different.
Input
Input is given from Standard Input in the following format:
N
a_1 b_1
a_2 b_2
:
a_N b_N
c_1 d_1
c_2 d_2
:
c_N d_N
Output
Print the maximum number of friendly pairs.
Examples
Input
3
2 0
3 1
1 3
4 2
0 4
5 5
Output
2
Input
3
0 0
1 1
5 2
2 3
3 4
4 5
Output
2
Input
2
2 2
3 3
0 0
1 1
Output
0
Input
5
0 0
7 3
2 2
4 8
1 6
8 5
6 9
5 4
9 1
3 7
Output
5
Input
5
0 0
1 1
5 5
6 6
7 7
2 2
3 3
4 4
8 8
9 9
Output
4
Submitted Solution:
```
N = int(input())
a = 0
x = []
y = []
for i in range(N):
s,t = map(int, input().split())
x.append([s*s+t*t,s,t])
for j in range(N):
u,v = map(int, input().split())
y.append([u*u+v*v,u,v])
x.reverse()
y.reverse()
for k in range(N):
for l in range(len(y)):
if x[k][1]<y[l][1] and x[k][2]<y[l][2]:
a += 1
y.pop(l)
break
print(a)
``` | instruction | 0 | 92,493 | 23 | 184,986 |
No | output | 1 | 92,493 | 23 | 184,987 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
On a two-dimensional plane, there are N red points and N blue points. The coordinates of the i-th red point are (a_i, b_i), and the coordinates of the i-th blue point are (c_i, d_i).
A red point and a blue point can form a friendly pair when, the x-coordinate of the red point is smaller than that of the blue point, and the y-coordinate of the red point is also smaller than that of the blue point.
At most how many friendly pairs can you form? Note that a point cannot belong to multiple pairs.
Constraints
* All input values are integers.
* 1 \leq N \leq 100
* 0 \leq a_i, b_i, c_i, d_i < 2N
* a_1, a_2, ..., a_N, c_1, c_2, ..., c_N are all different.
* b_1, b_2, ..., b_N, d_1, d_2, ..., d_N are all different.
Input
Input is given from Standard Input in the following format:
N
a_1 b_1
a_2 b_2
:
a_N b_N
c_1 d_1
c_2 d_2
:
c_N d_N
Output
Print the maximum number of friendly pairs.
Examples
Input
3
2 0
3 1
1 3
4 2
0 4
5 5
Output
2
Input
3
0 0
1 1
5 2
2 3
3 4
4 5
Output
2
Input
2
2 2
3 3
0 0
1 1
Output
0
Input
5
0 0
7 3
2 2
4 8
1 6
8 5
6 9
5 4
9 1
3 7
Output
5
Input
5
0 0
1 1
5 5
6 6
7 7
2 2
3 3
4 4
8 8
9 9
Output
4
Submitted Solution:
```
from itertools import permutations
N = int(input())
red = [list(map(int, input().split())) for _ in range(N)]
blue = [list(map(int, input().split())) for _ in range(N)]
def shuffle(l):
for i in permutations(l):
yield i
def judge(r, b):
cnt = 0
for i, j in zip(r, b):
if i[0] < j[0] and i[1] < j[1]:
cnt += 1
return cnt
print(max([judge(red, b) for b in shuffle(blue)]))
``` | instruction | 0 | 92,494 | 23 | 184,988 |
No | output | 1 | 92,494 | 23 | 184,989 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
On a two-dimensional plane, there are N red points and N blue points. The coordinates of the i-th red point are (a_i, b_i), and the coordinates of the i-th blue point are (c_i, d_i).
A red point and a blue point can form a friendly pair when, the x-coordinate of the red point is smaller than that of the blue point, and the y-coordinate of the red point is also smaller than that of the blue point.
At most how many friendly pairs can you form? Note that a point cannot belong to multiple pairs.
Constraints
* All input values are integers.
* 1 \leq N \leq 100
* 0 \leq a_i, b_i, c_i, d_i < 2N
* a_1, a_2, ..., a_N, c_1, c_2, ..., c_N are all different.
* b_1, b_2, ..., b_N, d_1, d_2, ..., d_N are all different.
Input
Input is given from Standard Input in the following format:
N
a_1 b_1
a_2 b_2
:
a_N b_N
c_1 d_1
c_2 d_2
:
c_N d_N
Output
Print the maximum number of friendly pairs.
Examples
Input
3
2 0
3 1
1 3
4 2
0 4
5 5
Output
2
Input
3
0 0
1 1
5 2
2 3
3 4
4 5
Output
2
Input
2
2 2
3 3
0 0
1 1
Output
0
Input
5
0 0
7 3
2 2
4 8
1 6
8 5
6 9
5 4
9 1
3 7
Output
5
Input
5
0 0
1 1
5 5
6 6
7 7
2 2
3 3
4 4
8 8
9 9
Output
4
Submitted Solution:
```
N=int(input())
red=sorted(list(map(int,input().split())) for i in range(N))
blue=sorted(list(map(int,input().split())) for i in range(N))
count=0
for i in red:
for n,j in enumerate(blue):
if i[0]<j[0] and i[1]<j[1]:
count+=1
del blue[n]
break
print(count)
``` | instruction | 0 | 92,495 | 23 | 184,990 |
No | output | 1 | 92,495 | 23 | 184,991 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
On a two-dimensional plane, there are N red points and N blue points. The coordinates of the i-th red point are (a_i, b_i), and the coordinates of the i-th blue point are (c_i, d_i).
A red point and a blue point can form a friendly pair when, the x-coordinate of the red point is smaller than that of the blue point, and the y-coordinate of the red point is also smaller than that of the blue point.
At most how many friendly pairs can you form? Note that a point cannot belong to multiple pairs.
Constraints
* All input values are integers.
* 1 \leq N \leq 100
* 0 \leq a_i, b_i, c_i, d_i < 2N
* a_1, a_2, ..., a_N, c_1, c_2, ..., c_N are all different.
* b_1, b_2, ..., b_N, d_1, d_2, ..., d_N are all different.
Input
Input is given from Standard Input in the following format:
N
a_1 b_1
a_2 b_2
:
a_N b_N
c_1 d_1
c_2 d_2
:
c_N d_N
Output
Print the maximum number of friendly pairs.
Examples
Input
3
2 0
3 1
1 3
4 2
0 4
5 5
Output
2
Input
3
0 0
1 1
5 2
2 3
3 4
4 5
Output
2
Input
2
2 2
3 3
0 0
1 1
Output
0
Input
5
0 0
7 3
2 2
4 8
1 6
8 5
6 9
5 4
9 1
3 7
Output
5
Input
5
0 0
1 1
5 5
6 6
7 7
2 2
3 3
4 4
8 8
9 9
Output
4
Submitted Solution:
```
N = int(input())
r = []
for _ in range(N):
x,y = map(int, input().split())
r.append((-y,x))
b = []
for _ in range(N):
x,y = map(int, input().split())
b.append((y,x))
r.sort()
b.sort()
ans = 0
for my,x in r:
for j in range(len(b)):
if -my < b[j][0] and x < b[j][1]:
ans += 1
b.pop(j)
break
print(ans)
``` | instruction | 0 | 92,496 | 23 | 184,992 |
No | output | 1 | 92,496 | 23 | 184,993 |
Provide a correct Python 3 solution for this coding contest problem.
A 3×3 grid with a integer written in each square, is called a magic square if and only if the integers in each row, the integers in each column, and the integers in each diagonal (from the top left corner to the bottom right corner, and from the top right corner to the bottom left corner), all add up to the same sum.
You are given the integers written in the following three squares in a magic square:
* The integer A at the upper row and left column
* The integer B at the upper row and middle column
* The integer C at the middle row and middle column
Determine the integers written in the remaining squares in the magic square.
It can be shown that there exists a unique magic square consistent with the given information.
Constraints
* 0 \leq A, B, C \leq 100
Input
The input is given from Standard Input in the following format:
A
B
C
Output
Output the integers written in the magic square, in the following format:
X_{1,1} X_{1,2} X_{1,3}
X_{2,1} X_{2,2} X_{2,3}
X_{3,1} X_{3,2} X_{3,3}
where X_{i,j} is the integer written in the square at the i-th row and j-th column.
Examples
Input
8
3
5
Output
8 3 4
1 5 9
6 7 2
Input
1
1
1
Output
1 1 1
1 1 1
1 1 1 | instruction | 0 | 92,500 | 23 | 185,000 |
"Correct Solution:
```
r11 = int(input())
r12 = int(input())
r22 = int(input())
r33 = r22 * 2 - r11
r32 = r22 * 2 - r12
r31 = r22 * 3 - r33 - r32
r21 = r22 * 3 - r11 - r31
r13 = r22 * 3 - r11 - r12
r23 = r22 * 3 - r13 - r33
print(r11, r12, r13)
print(r21, r22, r23)
print(r31, r32, r33)
``` | output | 1 | 92,500 | 23 | 185,001 |
Provide a correct Python 3 solution for this coding contest problem.
A 3×3 grid with a integer written in each square, is called a magic square if and only if the integers in each row, the integers in each column, and the integers in each diagonal (from the top left corner to the bottom right corner, and from the top right corner to the bottom left corner), all add up to the same sum.
You are given the integers written in the following three squares in a magic square:
* The integer A at the upper row and left column
* The integer B at the upper row and middle column
* The integer C at the middle row and middle column
Determine the integers written in the remaining squares in the magic square.
It can be shown that there exists a unique magic square consistent with the given information.
Constraints
* 0 \leq A, B, C \leq 100
Input
The input is given from Standard Input in the following format:
A
B
C
Output
Output the integers written in the magic square, in the following format:
X_{1,1} X_{1,2} X_{1,3}
X_{2,1} X_{2,2} X_{2,3}
X_{3,1} X_{3,2} X_{3,3}
where X_{i,j} is the integer written in the square at the i-th row and j-th column.
Examples
Input
8
3
5
Output
8 3 4
1 5 9
6 7 2
Input
1
1
1
Output
1 1 1
1 1 1
1 1 1 | instruction | 0 | 92,501 | 23 | 185,002 |
"Correct Solution:
```
A=int(input())
B=int(input())
C=int(input())
print(A,B,3*C-A-B)
print(4*C-2*A-B,C,2*A+B-2*C)
print(A+B-C,2*C-B,2*C-A)
``` | output | 1 | 92,501 | 23 | 185,003 |
Provide a correct Python 3 solution for this coding contest problem.
A 3×3 grid with a integer written in each square, is called a magic square if and only if the integers in each row, the integers in each column, and the integers in each diagonal (from the top left corner to the bottom right corner, and from the top right corner to the bottom left corner), all add up to the same sum.
You are given the integers written in the following three squares in a magic square:
* The integer A at the upper row and left column
* The integer B at the upper row and middle column
* The integer C at the middle row and middle column
Determine the integers written in the remaining squares in the magic square.
It can be shown that there exists a unique magic square consistent with the given information.
Constraints
* 0 \leq A, B, C \leq 100
Input
The input is given from Standard Input in the following format:
A
B
C
Output
Output the integers written in the magic square, in the following format:
X_{1,1} X_{1,2} X_{1,3}
X_{2,1} X_{2,2} X_{2,3}
X_{3,1} X_{3,2} X_{3,3}
where X_{i,j} is the integer written in the square at the i-th row and j-th column.
Examples
Input
8
3
5
Output
8 3 4
1 5 9
6 7 2
Input
1
1
1
Output
1 1 1
1 1 1
1 1 1 | instruction | 0 | 92,502 | 23 | 185,004 |
"Correct Solution:
```
def main():
A = int(input())
B = int(input())
C = int(input())
X = [[0] * 3 for _ in range(3)]
X[0][0] = A
X[0][1] = B
X[1][1] = C
X[2][0] = A + B - C
X[2][2] = B + C - X[2][0]
total = A + C + X[2][2]
X[0][2] = total - A - B
X[1][0] = total - A - X[2][0]
X[1][2] = total - X[1][0] - C
X[2][1] = total - B - C
for i in range(3):
print(*X[i])
if __name__ == "__main__":
main()
``` | output | 1 | 92,502 | 23 | 185,005 |
Provide a correct Python 3 solution for this coding contest problem.
A 3×3 grid with a integer written in each square, is called a magic square if and only if the integers in each row, the integers in each column, and the integers in each diagonal (from the top left corner to the bottom right corner, and from the top right corner to the bottom left corner), all add up to the same sum.
You are given the integers written in the following three squares in a magic square:
* The integer A at the upper row and left column
* The integer B at the upper row and middle column
* The integer C at the middle row and middle column
Determine the integers written in the remaining squares in the magic square.
It can be shown that there exists a unique magic square consistent with the given information.
Constraints
* 0 \leq A, B, C \leq 100
Input
The input is given from Standard Input in the following format:
A
B
C
Output
Output the integers written in the magic square, in the following format:
X_{1,1} X_{1,2} X_{1,3}
X_{2,1} X_{2,2} X_{2,3}
X_{3,1} X_{3,2} X_{3,3}
where X_{i,j} is the integer written in the square at the i-th row and j-th column.
Examples
Input
8
3
5
Output
8 3 4
1 5 9
6 7 2
Input
1
1
1
Output
1 1 1
1 1 1
1 1 1 | instruction | 0 | 92,503 | 23 | 185,006 |
"Correct Solution:
```
a = int(input())
b = int(input())
c = int(input())
print(a, b, 3*c-a-b)
print(-2*a-b+4*c, c, 2*a+b-2*c)
print(a+b-c, 2*c-b, 2*c-a)
``` | output | 1 | 92,503 | 23 | 185,007 |
Provide a correct Python 3 solution for this coding contest problem.
A 3×3 grid with a integer written in each square, is called a magic square if and only if the integers in each row, the integers in each column, and the integers in each diagonal (from the top left corner to the bottom right corner, and from the top right corner to the bottom left corner), all add up to the same sum.
You are given the integers written in the following three squares in a magic square:
* The integer A at the upper row and left column
* The integer B at the upper row and middle column
* The integer C at the middle row and middle column
Determine the integers written in the remaining squares in the magic square.
It can be shown that there exists a unique magic square consistent with the given information.
Constraints
* 0 \leq A, B, C \leq 100
Input
The input is given from Standard Input in the following format:
A
B
C
Output
Output the integers written in the magic square, in the following format:
X_{1,1} X_{1,2} X_{1,3}
X_{2,1} X_{2,2} X_{2,3}
X_{3,1} X_{3,2} X_{3,3}
where X_{i,j} is the integer written in the square at the i-th row and j-th column.
Examples
Input
8
3
5
Output
8 3 4
1 5 9
6 7 2
Input
1
1
1
Output
1 1 1
1 1 1
1 1 1 | instruction | 0 | 92,504 | 23 | 185,008 |
"Correct Solution:
```
a = int(input())
b = int(input())
c = int(input())
s = 3 * c
l = [
[a, b, s-a-b],
[2*s-2*a-b-2*c, c, 2*a+b+c-s],
[a+b+2*c-s, s-b-c, s-a-c]
]
for i in l:
print(*i)
``` | output | 1 | 92,504 | 23 | 185,009 |
Provide a correct Python 3 solution for this coding contest problem.
A 3×3 grid with a integer written in each square, is called a magic square if and only if the integers in each row, the integers in each column, and the integers in each diagonal (from the top left corner to the bottom right corner, and from the top right corner to the bottom left corner), all add up to the same sum.
You are given the integers written in the following three squares in a magic square:
* The integer A at the upper row and left column
* The integer B at the upper row and middle column
* The integer C at the middle row and middle column
Determine the integers written in the remaining squares in the magic square.
It can be shown that there exists a unique magic square consistent with the given information.
Constraints
* 0 \leq A, B, C \leq 100
Input
The input is given from Standard Input in the following format:
A
B
C
Output
Output the integers written in the magic square, in the following format:
X_{1,1} X_{1,2} X_{1,3}
X_{2,1} X_{2,2} X_{2,3}
X_{3,1} X_{3,2} X_{3,3}
where X_{i,j} is the integer written in the square at the i-th row and j-th column.
Examples
Input
8
3
5
Output
8 3 4
1 5 9
6 7 2
Input
1
1
1
Output
1 1 1
1 1 1
1 1 1 | instruction | 0 | 92,505 | 23 | 185,010 |
"Correct Solution:
```
A,B,C = int(input()),int(input()),int(input())
for n in range(-300,301):
ans = [[A,B,n],[0,C,0],[0,0,0]]
s = sum(ans[0])
ans[2][1] = s - B - C
ans[2][2] = s - C - A
ans[1][2] = s - n - ans[2][2]
ans[1][0] = s - C - ans[1][2]
ans[2][0] = s - A - ans[1][0]
if s == sum(ans[2]) == ans[0][2] + ans[1][1] + ans[2][0]:
for row in ans:
print(' '.join(map(str,row)))
break
``` | output | 1 | 92,505 | 23 | 185,011 |
Provide a correct Python 3 solution for this coding contest problem.
A 3×3 grid with a integer written in each square, is called a magic square if and only if the integers in each row, the integers in each column, and the integers in each diagonal (from the top left corner to the bottom right corner, and from the top right corner to the bottom left corner), all add up to the same sum.
You are given the integers written in the following three squares in a magic square:
* The integer A at the upper row and left column
* The integer B at the upper row and middle column
* The integer C at the middle row and middle column
Determine the integers written in the remaining squares in the magic square.
It can be shown that there exists a unique magic square consistent with the given information.
Constraints
* 0 \leq A, B, C \leq 100
Input
The input is given from Standard Input in the following format:
A
B
C
Output
Output the integers written in the magic square, in the following format:
X_{1,1} X_{1,2} X_{1,3}
X_{2,1} X_{2,2} X_{2,3}
X_{3,1} X_{3,2} X_{3,3}
where X_{i,j} is the integer written in the square at the i-th row and j-th column.
Examples
Input
8
3
5
Output
8 3 4
1 5 9
6 7 2
Input
1
1
1
Output
1 1 1
1 1 1
1 1 1 | instruction | 0 | 92,506 | 23 | 185,012 |
"Correct Solution:
```
def main():
X11 = int(input())
X12 = int(input())
X22 = int(input())
X13 = 0
while True:
v = X11 + X12 + X13 # 1st row
X31 = v - X13 - X22 # diag 2
X21 = v - X11 - X31 # 1st col
X23 = v - X21 - X22 # 2nd row
X33 = v - X13 - X23 # 3rd col
X32 = v - X12 - X22 # 2nd col
if X31 + X32 + X33 == v and X11 + X22 + X33 == v: # 3rd row, diag 1
print(" ".join(map(str, [X11, X12, X13])))
print(" ".join(map(str, [X21, X22, X23])))
print(" ".join(map(str, [X31, X32, X33])))
break
X13 += 1
if __name__ == '__main__':
main()
``` | output | 1 | 92,506 | 23 | 185,013 |
Provide a correct Python 3 solution for this coding contest problem.
A 3×3 grid with a integer written in each square, is called a magic square if and only if the integers in each row, the integers in each column, and the integers in each diagonal (from the top left corner to the bottom right corner, and from the top right corner to the bottom left corner), all add up to the same sum.
You are given the integers written in the following three squares in a magic square:
* The integer A at the upper row and left column
* The integer B at the upper row and middle column
* The integer C at the middle row and middle column
Determine the integers written in the remaining squares in the magic square.
It can be shown that there exists a unique magic square consistent with the given information.
Constraints
* 0 \leq A, B, C \leq 100
Input
The input is given from Standard Input in the following format:
A
B
C
Output
Output the integers written in the magic square, in the following format:
X_{1,1} X_{1,2} X_{1,3}
X_{2,1} X_{2,2} X_{2,3}
X_{3,1} X_{3,2} X_{3,3}
where X_{i,j} is the integer written in the square at the i-th row and j-th column.
Examples
Input
8
3
5
Output
8 3 4
1 5 9
6 7 2
Input
1
1
1
Output
1 1 1
1 1 1
1 1 1 | instruction | 0 | 92,507 | 23 | 185,014 |
"Correct Solution:
```
a=int(input())
b=int(input())
c=int(input())
d=c*3-a-b
g=c*2-d
h=c*2-b
i=c*2-a
e=c*3-a-g
f=c*3-d-i
print(a,b,d)
print(e,c,f)
print(g,h,i)
``` | output | 1 | 92,507 | 23 | 185,015 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
A 3×3 grid with a integer written in each square, is called a magic square if and only if the integers in each row, the integers in each column, and the integers in each diagonal (from the top left corner to the bottom right corner, and from the top right corner to the bottom left corner), all add up to the same sum.
You are given the integers written in the following three squares in a magic square:
* The integer A at the upper row and left column
* The integer B at the upper row and middle column
* The integer C at the middle row and middle column
Determine the integers written in the remaining squares in the magic square.
It can be shown that there exists a unique magic square consistent with the given information.
Constraints
* 0 \leq A, B, C \leq 100
Input
The input is given from Standard Input in the following format:
A
B
C
Output
Output the integers written in the magic square, in the following format:
X_{1,1} X_{1,2} X_{1,3}
X_{2,1} X_{2,2} X_{2,3}
X_{3,1} X_{3,2} X_{3,3}
where X_{i,j} is the integer written in the square at the i-th row and j-th column.
Examples
Input
8
3
5
Output
8 3 4
1 5 9
6 7 2
Input
1
1
1
Output
1 1 1
1 1 1
1 1 1
Submitted Solution:
```
a=int(input())
b=int(input())
c=int(input())
li1=[a,b,3*c-a-b]
li2=[4*c-2*a-b,c,2*a+b-2*c]
li3=[a+b-c,2*c-b,2*c-a]
print(*li1)
print(*li2)
print(*li3)
``` | instruction | 0 | 92,508 | 23 | 185,016 |
Yes | output | 1 | 92,508 | 23 | 185,017 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
A 3×3 grid with a integer written in each square, is called a magic square if and only if the integers in each row, the integers in each column, and the integers in each diagonal (from the top left corner to the bottom right corner, and from the top right corner to the bottom left corner), all add up to the same sum.
You are given the integers written in the following three squares in a magic square:
* The integer A at the upper row and left column
* The integer B at the upper row and middle column
* The integer C at the middle row and middle column
Determine the integers written in the remaining squares in the magic square.
It can be shown that there exists a unique magic square consistent with the given information.
Constraints
* 0 \leq A, B, C \leq 100
Input
The input is given from Standard Input in the following format:
A
B
C
Output
Output the integers written in the magic square, in the following format:
X_{1,1} X_{1,2} X_{1,3}
X_{2,1} X_{2,2} X_{2,3}
X_{3,1} X_{3,2} X_{3,3}
where X_{i,j} is the integer written in the square at the i-th row and j-th column.
Examples
Input
8
3
5
Output
8 3 4
1 5 9
6 7 2
Input
1
1
1
Output
1 1 1
1 1 1
1 1 1
Submitted Solution:
```
# -*- coding: utf-8 -*-
import sys
def input(): return sys.stdin.readline().strip()
def list2d(a, b, c): return [[c] * b for i in range(a)]
def list3d(a, b, c, d): return [[[d] * c for j in range(b)] for i in range(a)]
def list4d(a, b, c, d, e): return [[[[e] * d for j in range(c)] for j in range(b)] for i in range(a)]
def ceil(x, y=1): return int(-(-x // y))
def INT(): return int(input())
def MAP(): return map(int, input().split())
def LIST(N=None): return list(MAP()) if N is None else [INT() for i in range(N)]
def Yes(): print('Yes')
def No(): print('No')
def YES(): print('YES')
def NO(): print('NO')
sys.setrecursionlimit(10 ** 9)
INF = 10 ** 18
MOD = 10 ** 9 + 7
a = INT()
b = INT()
c = INT()
grid = list2d(3, 3, 0)
grid[0][0] = a
grid[0][1] = b
grid[1][1] = c
for i in range(301):
grid[0][2] = i - a - b
grid[2][2] = i - a - c
grid[2][1] = i - b - c
grid[1][2] = i - grid[0][2] - grid[2][2]
grid[1][0] = i - grid[1][1] - grid[1][2]
grid[2][0] = i - grid[0][0] - grid[1][0]
if grid[2][0] == i - grid[1][1] - grid[0][2] \
and grid[2][0] == i - grid[2][1] - grid[2][2]:
for i in range(3):
print(*grid[i])
exit()
``` | instruction | 0 | 92,509 | 23 | 185,018 |
Yes | output | 1 | 92,509 | 23 | 185,019 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
A 3×3 grid with a integer written in each square, is called a magic square if and only if the integers in each row, the integers in each column, and the integers in each diagonal (from the top left corner to the bottom right corner, and from the top right corner to the bottom left corner), all add up to the same sum.
You are given the integers written in the following three squares in a magic square:
* The integer A at the upper row and left column
* The integer B at the upper row and middle column
* The integer C at the middle row and middle column
Determine the integers written in the remaining squares in the magic square.
It can be shown that there exists a unique magic square consistent with the given information.
Constraints
* 0 \leq A, B, C \leq 100
Input
The input is given from Standard Input in the following format:
A
B
C
Output
Output the integers written in the magic square, in the following format:
X_{1,1} X_{1,2} X_{1,3}
X_{2,1} X_{2,2} X_{2,3}
X_{3,1} X_{3,2} X_{3,3}
where X_{i,j} is the integer written in the square at the i-th row and j-th column.
Examples
Input
8
3
5
Output
8 3 4
1 5 9
6 7 2
Input
1
1
1
Output
1 1 1
1 1 1
1 1 1
Submitted Solution:
```
# -*- coding: utf-8 -*-
def main():
a = int(input())
b = int(input())
e = int(input())
g = a + b - e
i = b + e - g
f = a + g - e
c = a + i - g
d = b + c - g
h = a + d - i
print(a, b, c)
print(d, e, f)
print(g, h, i)
if __name__ == '__main__':
main()
``` | instruction | 0 | 92,510 | 23 | 185,020 |
Yes | output | 1 | 92,510 | 23 | 185,021 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
A 3×3 grid with a integer written in each square, is called a magic square if and only if the integers in each row, the integers in each column, and the integers in each diagonal (from the top left corner to the bottom right corner, and from the top right corner to the bottom left corner), all add up to the same sum.
You are given the integers written in the following three squares in a magic square:
* The integer A at the upper row and left column
* The integer B at the upper row and middle column
* The integer C at the middle row and middle column
Determine the integers written in the remaining squares in the magic square.
It can be shown that there exists a unique magic square consistent with the given information.
Constraints
* 0 \leq A, B, C \leq 100
Input
The input is given from Standard Input in the following format:
A
B
C
Output
Output the integers written in the magic square, in the following format:
X_{1,1} X_{1,2} X_{1,3}
X_{2,1} X_{2,2} X_{2,3}
X_{3,1} X_{3,2} X_{3,3}
where X_{i,j} is the integer written in the square at the i-th row and j-th column.
Examples
Input
8
3
5
Output
8 3 4
1 5 9
6 7 2
Input
1
1
1
Output
1 1 1
1 1 1
1 1 1
Submitted Solution:
```
a,b,c=[int(input()) for _ in range(3)]
s=3*c
print(a,b,s-a-b)
print(2*s-2*a-b-2*c,c,2*a+b+c-s)
print(a+b+2*c-s,s-b-c,s-a-c)
``` | instruction | 0 | 92,511 | 23 | 185,022 |
Yes | output | 1 | 92,511 | 23 | 185,023 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
A 3×3 grid with a integer written in each square, is called a magic square if and only if the integers in each row, the integers in each column, and the integers in each diagonal (from the top left corner to the bottom right corner, and from the top right corner to the bottom left corner), all add up to the same sum.
You are given the integers written in the following three squares in a magic square:
* The integer A at the upper row and left column
* The integer B at the upper row and middle column
* The integer C at the middle row and middle column
Determine the integers written in the remaining squares in the magic square.
It can be shown that there exists a unique magic square consistent with the given information.
Constraints
* 0 \leq A, B, C \leq 100
Input
The input is given from Standard Input in the following format:
A
B
C
Output
Output the integers written in the magic square, in the following format:
X_{1,1} X_{1,2} X_{1,3}
X_{2,1} X_{2,2} X_{2,3}
X_{3,1} X_{3,2} X_{3,3}
where X_{i,j} is the integer written in the square at the i-th row and j-th column.
Examples
Input
8
3
5
Output
8 3 4
1 5 9
6 7 2
Input
1
1
1
Output
1 1 1
1 1 1
1 1 1
Submitted Solution:
```
x11, x12, x22 = (int(input()) for _ in range(3))
sum = x11 + x12 + x22
x13, x32, x33 = sum-(x11+x12), sum-(x12+x22), sum-(x11+x12)
x23, x31 = sum-(x13+x33), sum-(x13+x22)
x21 = sum-(x22+x23)
print('%d %d %d\n%d %d %d\n%d %d %d' % (x11,x12,x13,x21,x22,x23,x31,x32,x33))
``` | instruction | 0 | 92,512 | 23 | 185,024 |
No | output | 1 | 92,512 | 23 | 185,025 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
A 3×3 grid with a integer written in each square, is called a magic square if and only if the integers in each row, the integers in each column, and the integers in each diagonal (from the top left corner to the bottom right corner, and from the top right corner to the bottom left corner), all add up to the same sum.
You are given the integers written in the following three squares in a magic square:
* The integer A at the upper row and left column
* The integer B at the upper row and middle column
* The integer C at the middle row and middle column
Determine the integers written in the remaining squares in the magic square.
It can be shown that there exists a unique magic square consistent with the given information.
Constraints
* 0 \leq A, B, C \leq 100
Input
The input is given from Standard Input in the following format:
A
B
C
Output
Output the integers written in the magic square, in the following format:
X_{1,1} X_{1,2} X_{1,3}
X_{2,1} X_{2,2} X_{2,3}
X_{3,1} X_{3,2} X_{3,3}
where X_{i,j} is the integer written in the square at the i-th row and j-th column.
Examples
Input
8
3
5
Output
8 3 4
1 5 9
6 7 2
Input
1
1
1
Output
1 1 1
1 1 1
1 1 1
Submitted Solution:
```
# -*- coding: utf-8 -*-
def main():
a = int(input())
b = int(input())
c = int(input())
# a b e
# g c i
# h d f
for total in range(1000 + 1):
d = total - (b + c)
e = total - (a + b)
f = total - (a + c)
if 0 <= d and 0 <= e and 0 <= f:
i = total - (e + f)
h = total - (e + c)
g = total - (a + h)
if 0 <= i and 0 <= h and 0 <= g:
if total == (d + f + h) and total == (e + i + f) and total == (g + c + i) and total == (a + b + e) and total == (a + g + h) and total == (b + c + d) and total == (a + c + f) and total == (e + c + h):
print(a, b, e)
print(g, c, i)
print(h, d, f)
exit()
if __name__ == '__main__':
main()
``` | instruction | 0 | 92,513 | 23 | 185,026 |
No | output | 1 | 92,513 | 23 | 185,027 |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.