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 a correct Python 3 solution for this coding contest problem.
Create a program that rotates the pattern of 8 characters x 8 lines clockwise by 90 degrees, 180 degrees, and 270 degrees and outputs it.
Input
A pattern consisting of 8 characters x 8 lines is given. Characters consist of alphanumeric characters, half-width pound'#', and asterisk'*'.
Output
Output the rotated pattern in the following format.
90 (fixed half-width numbers)
Pattern rotated 90 degrees
180 (fixed half-width numbers)
180 degree rotated pattern
270 (fixed half-width numbers)
Pattern rotated 270 degrees
Examples
Input
#*******
#*******
#*******
#*******
#*******
#*******
#*******
########
Output
90
########
#*******
#*******
#*******
#*******
#*******
#*******
#*******
180
########
*******#
*******#
*******#
*******#
*******#
*******#
*******#
270
*******#
*******#
*******#
*******#
*******#
*******#
*******#
########
Input
*******
*******
*******
*******
*******
*******
*******
Output
90
*******
*******
*******
*******
*******
*******
*******
180
*******#
*******#
*******#
*******#
*******#
*******#
*******#
270
*******#
*******#
*******#
*******#
*******#
*******#
*******# | instruction | 0 | 79,839 | 23 | 159,678 |
"Correct Solution:
```
def spin(p):
ret = [[None] * 8 for _ in range(8)]
for i in range(8):
for j in range(8):
ret[i][j] = p[7 - j][i]
return ret
def print_p(p):
for line in p:
print("".join(line))
p = [input() for _ in range(8)]
print(90)
p = spin(p)
print_p(p)
print(180)
p = spin(p)
print_p(p)
print(270)
p = spin(p)
print_p(p)
``` | output | 1 | 79,839 | 23 | 159,679 |
Provide a correct Python 3 solution for this coding contest problem.
Create a program that rotates the pattern of 8 characters x 8 lines clockwise by 90 degrees, 180 degrees, and 270 degrees and outputs it.
Input
A pattern consisting of 8 characters x 8 lines is given. Characters consist of alphanumeric characters, half-width pound'#', and asterisk'*'.
Output
Output the rotated pattern in the following format.
90 (fixed half-width numbers)
Pattern rotated 90 degrees
180 (fixed half-width numbers)
180 degree rotated pattern
270 (fixed half-width numbers)
Pattern rotated 270 degrees
Examples
Input
#*******
#*******
#*******
#*******
#*******
#*******
#*******
########
Output
90
########
#*******
#*******
#*******
#*******
#*******
#*******
#*******
180
########
*******#
*******#
*******#
*******#
*******#
*******#
*******#
270
*******#
*******#
*******#
*******#
*******#
*******#
*******#
########
Input
*******
*******
*******
*******
*******
*******
*******
Output
90
*******
*******
*******
*******
*******
*******
*******
180
*******#
*******#
*******#
*******#
*******#
*******#
*******#
270
*******#
*******#
*******#
*******#
*******#
*******#
*******# | instruction | 0 | 79,840 | 23 | 159,680 |
"Correct Solution:
```
# -*- coding: utf-8 -*-
"""
http://judge.u-aizu.ac.jp/onlinejudge/description.jsp?id=0133
"""
import sys
from sys import stdin
input = stdin.readline
def rotate_ccw(data):
A = [[''] * 8 for _ in range(8)]
for i in range(8):
for j in range(8):
A[i][j] = data[j][7-i]
for l in A:
print(''.join(l))
return A
def rotate_cw(data):
A = [[''] * 8 for _ in range(8)]
for i in range(8):
for j in range(8):
A[i][j] = data[7-j][i]
for l in A:
print(''.join(l))
return A
def main(args):
data = []
for _ in range(8):
data.append(list(input().strip()))
print('90')
data = rotate_cw(data)
print('180')
data = rotate_cw(data)
print('270')
data = rotate_cw(data)
if __name__ == '__main__':
main(sys.argv[1:])
``` | output | 1 | 79,840 | 23 | 159,681 |
Provide a correct Python 3 solution for this coding contest problem.
Create a program that rotates the pattern of 8 characters x 8 lines clockwise by 90 degrees, 180 degrees, and 270 degrees and outputs it.
Input
A pattern consisting of 8 characters x 8 lines is given. Characters consist of alphanumeric characters, half-width pound'#', and asterisk'*'.
Output
Output the rotated pattern in the following format.
90 (fixed half-width numbers)
Pattern rotated 90 degrees
180 (fixed half-width numbers)
180 degree rotated pattern
270 (fixed half-width numbers)
Pattern rotated 270 degrees
Examples
Input
#*******
#*******
#*******
#*******
#*******
#*******
#*******
########
Output
90
########
#*******
#*******
#*******
#*******
#*******
#*******
#*******
180
########
*******#
*******#
*******#
*******#
*******#
*******#
*******#
270
*******#
*******#
*******#
*******#
*******#
*******#
*******#
########
Input
*******
*******
*******
*******
*******
*******
*******
Output
90
*******
*******
*******
*******
*******
*******
*******
180
*******#
*******#
*******#
*******#
*******#
*******#
*******#
270
*******#
*******#
*******#
*******#
*******#
*******#
*******# | instruction | 0 | 79,841 | 23 | 159,682 |
"Correct Solution:
```
MAX=8
L = [ [None] * MAX for x in range(MAX) ]
for i in range(MAX):
l = list(input())
L[i] = l
T = [ [None] * MAX for x in range(MAX) ]
for r in range(1,4):
print(r*90)
for i in range(MAX):
for j in range(MAX):
T[i][j] = L[MAX-1-j][i]
L = T
T = [ [None] * MAX for x in range(MAX) ]
for l in L:
print("".join(l))
``` | output | 1 | 79,841 | 23 | 159,683 |
Provide a correct Python 3 solution for this coding contest problem.
Create a program that rotates the pattern of 8 characters x 8 lines clockwise by 90 degrees, 180 degrees, and 270 degrees and outputs it.
Input
A pattern consisting of 8 characters x 8 lines is given. Characters consist of alphanumeric characters, half-width pound'#', and asterisk'*'.
Output
Output the rotated pattern in the following format.
90 (fixed half-width numbers)
Pattern rotated 90 degrees
180 (fixed half-width numbers)
180 degree rotated pattern
270 (fixed half-width numbers)
Pattern rotated 270 degrees
Examples
Input
#*******
#*******
#*******
#*******
#*******
#*******
#*******
########
Output
90
########
#*******
#*******
#*******
#*******
#*******
#*******
#*******
180
########
*******#
*******#
*******#
*******#
*******#
*******#
*******#
270
*******#
*******#
*******#
*******#
*******#
*******#
*******#
########
Input
*******
*******
*******
*******
*******
*******
*******
Output
90
*******
*******
*******
*******
*******
*******
*******
180
*******#
*******#
*******#
*******#
*******#
*******#
*******#
270
*******#
*******#
*******#
*******#
*******#
*******#
*******# | instruction | 0 | 79,842 | 23 | 159,684 |
"Correct Solution:
```
def Draw(pattern, rowRange, colRange):
s = ""
for row in rowRange:
for col in colRange:
s += pattern[row][col]
s += "\n"
print(s, end="")
def Draw2(pattern, colRange, rowRange):
s = ""
for col in colRange:
for row in rowRange:
s += pattern[row][col]
s += "\n"
print(s, end="")
pattern = [input() for lp in range(8)]
print("90")
Draw2(pattern, range(0, 8), range(7, -1, -1))
print("180")
Draw(pattern, range(7, -1, -1), range(7, -1, -1))
print("270")
Draw2(pattern, range(7, -1, -1), range(0, 8))
``` | output | 1 | 79,842 | 23 | 159,685 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
Create a program that rotates the pattern of 8 characters x 8 lines clockwise by 90 degrees, 180 degrees, and 270 degrees and outputs it.
Input
A pattern consisting of 8 characters x 8 lines is given. Characters consist of alphanumeric characters, half-width pound'#', and asterisk'*'.
Output
Output the rotated pattern in the following format.
90 (fixed half-width numbers)
Pattern rotated 90 degrees
180 (fixed half-width numbers)
180 degree rotated pattern
270 (fixed half-width numbers)
Pattern rotated 270 degrees
Examples
Input
#*******
#*******
#*******
#*******
#*******
#*******
#*******
########
Output
90
########
#*******
#*******
#*******
#*******
#*******
#*******
#*******
180
########
*******#
*******#
*******#
*******#
*******#
*******#
*******#
270
*******#
*******#
*******#
*******#
*******#
*******#
*******#
########
Input
*******
*******
*******
*******
*******
*******
*******
Output
90
*******
*******
*******
*******
*******
*******
*******
180
*******#
*******#
*******#
*******#
*******#
*******#
*******#
270
*******#
*******#
*******#
*******#
*******#
*******#
*******#
Submitted Solution:
```
m=[input() for _ in range(8)]
for i in range(3):
m=list(zip(*m[::-1]))
print(90*(i+1))
for x in m:
print(''.join(x))
``` | instruction | 0 | 79,843 | 23 | 159,686 |
Yes | output | 1 | 79,843 | 23 | 159,687 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
Create a program that rotates the pattern of 8 characters x 8 lines clockwise by 90 degrees, 180 degrees, and 270 degrees and outputs it.
Input
A pattern consisting of 8 characters x 8 lines is given. Characters consist of alphanumeric characters, half-width pound'#', and asterisk'*'.
Output
Output the rotated pattern in the following format.
90 (fixed half-width numbers)
Pattern rotated 90 degrees
180 (fixed half-width numbers)
180 degree rotated pattern
270 (fixed half-width numbers)
Pattern rotated 270 degrees
Examples
Input
#*******
#*******
#*******
#*******
#*******
#*******
#*******
########
Output
90
########
#*******
#*******
#*******
#*******
#*******
#*******
#*******
180
########
*******#
*******#
*******#
*******#
*******#
*******#
*******#
270
*******#
*******#
*******#
*******#
*******#
*******#
*******#
########
Input
*******
*******
*******
*******
*******
*******
*******
Output
90
*******
*******
*******
*******
*******
*******
*******
180
*******#
*******#
*******#
*******#
*******#
*******#
*******#
270
*******#
*******#
*******#
*******#
*******#
*******#
*******#
Submitted Solution:
```
m=[input() for _ in range(8)]
print(90)
a=-1
for j in range(8):
for i in range(7,a,a):
print(m[i][j],end='')
print()
print(180)
for i in range(7,a,a):
for j in range(7,a,a):
print(m[i][j],end='')
print()
print(270)
for j in range(7,a,a):
for i in range(8):
print(m[i][j],end='')
print()
``` | instruction | 0 | 79,844 | 23 | 159,688 |
Yes | output | 1 | 79,844 | 23 | 159,689 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
Create a program that rotates the pattern of 8 characters x 8 lines clockwise by 90 degrees, 180 degrees, and 270 degrees and outputs it.
Input
A pattern consisting of 8 characters x 8 lines is given. Characters consist of alphanumeric characters, half-width pound'#', and asterisk'*'.
Output
Output the rotated pattern in the following format.
90 (fixed half-width numbers)
Pattern rotated 90 degrees
180 (fixed half-width numbers)
180 degree rotated pattern
270 (fixed half-width numbers)
Pattern rotated 270 degrees
Examples
Input
#*******
#*******
#*******
#*******
#*******
#*******
#*******
########
Output
90
########
#*******
#*******
#*******
#*******
#*******
#*******
#*******
180
########
*******#
*******#
*******#
*******#
*******#
*******#
*******#
270
*******#
*******#
*******#
*******#
*******#
*******#
*******#
########
Input
*******
*******
*******
*******
*******
*******
*******
Output
90
*******
*******
*******
*******
*******
*******
*******
180
*******#
*******#
*******#
*******#
*******#
*******#
*******#
270
*******#
*******#
*******#
*******#
*******#
*******#
*******#
Submitted Solution:
```
def rotate(m,n):
print(90*n)
for i in range(8):
print(''.join(m[i]),end='')
print()
m=[input() for _ in range(8)]
for i in range(3):
m=list(zip(*m[::-1]))
rotate(m,i+1)
``` | instruction | 0 | 79,845 | 23 | 159,690 |
Yes | output | 1 | 79,845 | 23 | 159,691 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
Create a program that rotates the pattern of 8 characters x 8 lines clockwise by 90 degrees, 180 degrees, and 270 degrees and outputs it.
Input
A pattern consisting of 8 characters x 8 lines is given. Characters consist of alphanumeric characters, half-width pound'#', and asterisk'*'.
Output
Output the rotated pattern in the following format.
90 (fixed half-width numbers)
Pattern rotated 90 degrees
180 (fixed half-width numbers)
180 degree rotated pattern
270 (fixed half-width numbers)
Pattern rotated 270 degrees
Examples
Input
#*******
#*******
#*******
#*******
#*******
#*******
#*******
########
Output
90
########
#*******
#*******
#*******
#*******
#*******
#*******
#*******
180
########
*******#
*******#
*******#
*******#
*******#
*******#
*******#
270
*******#
*******#
*******#
*******#
*******#
*******#
*******#
########
Input
*******
*******
*******
*******
*******
*******
*******
Output
90
*******
*******
*******
*******
*******
*******
*******
180
*******#
*******#
*******#
*******#
*******#
*******#
*******#
270
*******#
*******#
*******#
*******#
*******#
*******#
*******#
Submitted Solution:
```
def rotate(k, p):
q=[]
print('90' if k==1 else('180' if k==2 else '270'))
for i in range(8):
t=''
for j in range(8)[::-1]:
print(p[j][i], end='')
t+=p[j][i]
q.append(t)
print()
return q
p= [input() for _ in range(8)]
for i in range(1, 4):
p= rotate(i, p)
``` | instruction | 0 | 79,846 | 23 | 159,692 |
Yes | output | 1 | 79,846 | 23 | 159,693 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
Create a program that rotates the pattern of 8 characters x 8 lines clockwise by 90 degrees, 180 degrees, and 270 degrees and outputs it.
Input
A pattern consisting of 8 characters x 8 lines is given. Characters consist of alphanumeric characters, half-width pound'#', and asterisk'*'.
Output
Output the rotated pattern in the following format.
90 (fixed half-width numbers)
Pattern rotated 90 degrees
180 (fixed half-width numbers)
180 degree rotated pattern
270 (fixed half-width numbers)
Pattern rotated 270 degrees
Examples
Input
#*******
#*******
#*******
#*******
#*******
#*******
#*******
########
Output
90
########
#*******
#*******
#*******
#*******
#*******
#*******
#*******
180
########
*******#
*******#
*******#
*******#
*******#
*******#
*******#
270
*******#
*******#
*******#
*******#
*******#
*******#
*******#
########
Input
*******
*******
*******
*******
*******
*******
*******
Output
90
*******
*******
*******
*******
*******
*******
*******
180
*******#
*******#
*******#
*******#
*******#
*******#
*******#
270
*******#
*******#
*******#
*******#
*******#
*******#
*******#
Submitted Solution:
```
def Draw(pattern, rowRange, colRange):
s = ""
for row in rowRange:
for col in colRange:
s += pattern[row][col]
s += "\n"
print(s, end="")
pattern = [input() for lp in range(8)]
print("90")
Draw(pattern, range(7, -1, -1), range(0, 8))
print("180")
Draw(pattern, range(7, -1, -1), range(7, -1, -1))
print("270")
Draw(pattern, range(0, 8), range(7, -1, -1))
``` | instruction | 0 | 79,847 | 23 | 159,694 |
No | output | 1 | 79,847 | 23 | 159,695 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
Create a program that rotates the pattern of 8 characters x 8 lines clockwise by 90 degrees, 180 degrees, and 270 degrees and outputs it.
Input
A pattern consisting of 8 characters x 8 lines is given. Characters consist of alphanumeric characters, half-width pound'#', and asterisk'*'.
Output
Output the rotated pattern in the following format.
90 (fixed half-width numbers)
Pattern rotated 90 degrees
180 (fixed half-width numbers)
180 degree rotated pattern
270 (fixed half-width numbers)
Pattern rotated 270 degrees
Examples
Input
#*******
#*******
#*******
#*******
#*******
#*******
#*******
########
Output
90
########
#*******
#*******
#*******
#*******
#*******
#*******
#*******
180
########
*******#
*******#
*******#
*******#
*******#
*******#
*******#
270
*******#
*******#
*******#
*******#
*******#
*******#
*******#
########
Input
*******
*******
*******
*******
*******
*******
*******
Output
90
*******
*******
*******
*******
*******
*******
*******
180
*******#
*******#
*******#
*******#
*******#
*******#
*******#
270
*******#
*******#
*******#
*******#
*******#
*******#
*******#
Submitted Solution:
```
m=[input() for _ in range(8)]
for i in range(3):
m=list(zip(*m[::-1]))
print(90*i)
for x in m:
print(''.join(x))
``` | instruction | 0 | 79,848 | 23 | 159,696 |
No | output | 1 | 79,848 | 23 | 159,697 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
Petya recently found a game "Choose a Square". In this game, there are n points numbered from 1 to n on an infinite field. The i-th point has coordinates (x_i, y_i) and cost c_i.
You have to choose a square such that its sides are parallel to coordinate axes, the lower left and upper right corners belong to the line y = x, and all corners have integer coordinates.
The score you get is the sum of costs of the points covered by the selected square minus the length of the side of the square. Note that the length of the side can be zero.
Petya asks you to calculate the maximum possible score in the game that can be achieved by placing exactly one square.
Input
The first line of the input contains one integer n (1 ≤ n ≤ 5 ⋅ 10^5) — the number of points on the field.
Each of the following n lines contains three integers x_i, y_i, c_i (0 ≤ x_i, y_i ≤ 10^9, -10^6 ≤ c_i ≤ 10^6) — coordinates of the i-th point and its cost, respectively.
Output
In the first line print the maximum score Petya can achieve.
In the second line print four integers x_1, y_1, x_2, y_2 (0 ≤ x_1, y_1, x_2, y_2 ≤ 2 ⋅ 10^9, x_1 = y_1, x_2 = y_2, x_1 ≤ x_2) separated by spaces — the coordinates of the lower left and upper right corners of the square which Petya has to select in order to achieve the maximum score.
Examples
Input
6
0 0 2
1 0 -5
1 1 3
2 3 4
1 4 -4
3 1 -1
Output
4
1 1 3 3
Input
5
3 3 0
3 3 -3
0 2 -1
3 1 3
0 0 -2
Output
0
1 1 1 1
Note
The field corresponding to the first example: <image>
Submitted Solution:
```
def scoreSq(i1,j1,l) :
s = 0
for i,j,k in l :
if (i in range(j1,i1+1) and j in [i1,j1]) or (j in range(j1,i1+1) and i in [i1,j1]) :
s += k
return s
n = int(input())
l = []
for i in range(n) :
l.append(tuple(map(int,input().split())))
maxa = max([l[i][0] for i in range(n)])
maxc = max([l[i][1] for i in range(n)])
m = max(maxa,maxc)
s = -1
c1,c2=-1,-1
for i in range(m+1) :
for j in range(i) :
if scoreSq(i,j,l) > s :
c1,c2,s = i,j,scoreSq(i,j,l)
print(s)
print(c2,c2,c1,c1)
``` | instruction | 0 | 80,019 | 23 | 160,038 |
No | output | 1 | 80,019 | 23 | 160,039 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
Petya recently found a game "Choose a Square". In this game, there are n points numbered from 1 to n on an infinite field. The i-th point has coordinates (x_i, y_i) and cost c_i.
You have to choose a square such that its sides are parallel to coordinate axes, the lower left and upper right corners belong to the line y = x, and all corners have integer coordinates.
The score you get is the sum of costs of the points covered by the selected square minus the length of the side of the square. Note that the length of the side can be zero.
Petya asks you to calculate the maximum possible score in the game that can be achieved by placing exactly one square.
Input
The first line of the input contains one integer n (1 ≤ n ≤ 5 ⋅ 10^5) — the number of points on the field.
Each of the following n lines contains three integers x_i, y_i, c_i (0 ≤ x_i, y_i ≤ 10^9, -10^6 ≤ c_i ≤ 10^6) — coordinates of the i-th point and its cost, respectively.
Output
In the first line print the maximum score Petya can achieve.
In the second line print four integers x_1, y_1, x_2, y_2 (0 ≤ x_1, y_1, x_2, y_2 ≤ 2 ⋅ 10^9, x_1 = y_1, x_2 = y_2, x_1 ≤ x_2) separated by spaces — the coordinates of the lower left and upper right corners of the square which Petya has to select in order to achieve the maximum score.
Examples
Input
6
0 0 2
1 0 -5
1 1 3
2 3 4
1 4 -4
3 1 -1
Output
4
1 1 3 3
Input
5
3 3 0
3 3 -3
0 2 -1
3 1 3
0 0 -2
Output
0
1 1 1 1
Note
The field corresponding to the first example: <image>
Submitted Solution:
```
def main():
import sys
import time
input = sys.stdin.buffer.readline
t0 = time.time()
N = int(input())
left = {}
right = {}
idx2val = set()
idx2val_r = set()
for _ in range(N):
x, y, c = map(int, input().split())
if x > y:
x, y = y, x
if x in left:
left[x].append((y, c))
else:
left[x] = [(y, c)]
if y in right:
right[y] += c
else:
right[y] = c
idx2val.add(x)
idx2val.add(y)
idx2val_r.add(y)
idx2val = sorted(list(idx2val))
idx2val_r = sorted(list(idx2val_r))
val2idx = {val: idx for idx, val in enumerate(idx2val_r)}
n = len(idx2val)
nr = len(right)
t1 = time.time()-t0
# N: 処理する区間の長さ
INF = 2 ** 40 - 1
LV = nr.bit_length()
N0 = 2 ** LV
data = [0] * (2 * N0)
lazy = [0] * (2 * N0)
def gindex(l, r):
L = (l + N0) >> 1
R = (r + N0) >> 1
lc = 0 if l & 1 else (L & -L).bit_length()
rc = 0 if r & 1 else (R & -R).bit_length()
for i in range(LV):
if rc <= i:
yield R
if L < R and lc <= i:
yield L
L >>= 1
R >>= 1
# 遅延伝搬処理
def propagates(*ids):
for i in reversed(ids):
v = lazy[i - 1]
if not v:
continue
lazy[2 * i - 1] += v
lazy[2 * i] += v
data[2 * i - 1] += v
data[2 * i] += v
lazy[i - 1] = 0
# 区間[l, r)にxを加算
def update(l, r, x):
*ids, = gindex(l, r)
propagates(*ids)
L = N0 + l
R = N0 + r
while L < R:
if R & 1:
R -= 1
lazy[R - 1] += x
data[R - 1] += x
if L & 1:
lazy[L - 1] += x
data[L - 1] += x
L += 1
L >>= 1
R >>= 1
for i in ids:
d1 = data[2 * i - 1]
d2 = data[2 * i]
if d1 > d2:
data[i-1] = d1
else:
data[i-1] = d2
# 区間[l, r)内の最小値を求める
def query(l, r):
propagates(*gindex(l, r))
L = N0 + l
R = N0 + r
s = -INF
while L < R:
if R & 1:
R -= 1
if data[R-1] > s:
s = data[R-1]
if L & 1:
if data[L-1] > s:
s = data[L-1]
L += 1
L >>= 1
R >>= 1
return s
ans = 0
ans_left = -1
cost = 0
for i in range(n):
val = idx2val[i]
cost -= val - idx2val[max(i - 1, 0)]
if val in right:
cost += right[val]
j = val2idx[val]
update(j+1, j+2, cost)
tmp = query(1, nr+1)
if tmp > ans:
ans = tmp
ans_left = 0
C = 0
val_left_prev = idx2val[0]
k = 0 if idx2val[0] not in right else 1
for i in range(1, n):
if time.time() - t0 > 5.5:
print(i, n, t1)
exit()
val = idx2val[i]
val_prev = idx2val[i-1]
C += val - val_prev
if val not in left:
k += 1
continue
for y, c in left[val_left_prev]:
j = val2idx[y]
update(j+1, nr+1, -c)
val_left_prev = val
q_prev = query(k+1, nr+1)
tmp = q_prev + C
if val in right:
k += 1
if tmp > ans:
ans = tmp
ans_left = i
print(ans)
if ans_left == -1:
print(*[2*10**9] * 4)
else:
cost = 0
right = {}
for i in range(ans_left, n):
val = idx2val[i]
if val in left:
for y, c in left[val]:
if y in right:
right[y] += c
else:
right[y] = c
for i in range(ans_left, n):
val = idx2val[i]
if val in right:
cost += right[val]
cost -= val - idx2val[max(i - 1, ans_left)]
if cost == ans:
small = idx2val[ans_left]
large = idx2val[i]
print(small, small, large, large)
break
if __name__ == '__main__':
main()
``` | instruction | 0 | 80,020 | 23 | 160,040 |
No | output | 1 | 80,020 | 23 | 160,041 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
Petya recently found a game "Choose a Square". In this game, there are n points numbered from 1 to n on an infinite field. The i-th point has coordinates (x_i, y_i) and cost c_i.
You have to choose a square such that its sides are parallel to coordinate axes, the lower left and upper right corners belong to the line y = x, and all corners have integer coordinates.
The score you get is the sum of costs of the points covered by the selected square minus the length of the side of the square. Note that the length of the side can be zero.
Petya asks you to calculate the maximum possible score in the game that can be achieved by placing exactly one square.
Input
The first line of the input contains one integer n (1 ≤ n ≤ 5 ⋅ 10^5) — the number of points on the field.
Each of the following n lines contains three integers x_i, y_i, c_i (0 ≤ x_i, y_i ≤ 10^9, -10^6 ≤ c_i ≤ 10^6) — coordinates of the i-th point and its cost, respectively.
Output
In the first line print the maximum score Petya can achieve.
In the second line print four integers x_1, y_1, x_2, y_2 (0 ≤ x_1, y_1, x_2, y_2 ≤ 2 ⋅ 10^9, x_1 = y_1, x_2 = y_2, x_1 ≤ x_2) separated by spaces — the coordinates of the lower left and upper right corners of the square which Petya has to select in order to achieve the maximum score.
Examples
Input
6
0 0 2
1 0 -5
1 1 3
2 3 4
1 4 -4
3 1 -1
Output
4
1 1 3 3
Input
5
3 3 0
3 3 -3
0 2 -1
3 1 3
0 0 -2
Output
0
1 1 1 1
Note
The field corresponding to the first example: <image>
Submitted Solution:
```
def scoreSq(i1,j1,l) :
s = 0
for i,j,k in l :
if (i in range(j1,i1+1) and j in [i1,j1]) or (j in range(j1,i1+1) and i in [i1,j1]) :
s += k
return s
n = int(input())
l = []
for i in range(n) :
l.append(tuple(map(int,input().split())))
maxa = max([l[i][0] for i in range(n)])
maxc = max([l[i][1] for i in range(n)])
m = max(maxa,maxc)
s = -1000000000000
c1,c2=-1,-1
for i in range(m+1) :
for j in range(i+1) :
if scoreSq(i,j,l)+(j-i) > s:
c1,c2,s = i,j,scoreSq(i,j,l)+(j-i)
print(s)
print(c2,c2,c1,c1)
``` | instruction | 0 | 80,021 | 23 | 160,042 |
No | output | 1 | 80,021 | 23 | 160,043 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
Petya recently found a game "Choose a Square". In this game, there are n points numbered from 1 to n on an infinite field. The i-th point has coordinates (x_i, y_i) and cost c_i.
You have to choose a square such that its sides are parallel to coordinate axes, the lower left and upper right corners belong to the line y = x, and all corners have integer coordinates.
The score you get is the sum of costs of the points covered by the selected square minus the length of the side of the square. Note that the length of the side can be zero.
Petya asks you to calculate the maximum possible score in the game that can be achieved by placing exactly one square.
Input
The first line of the input contains one integer n (1 ≤ n ≤ 5 ⋅ 10^5) — the number of points on the field.
Each of the following n lines contains three integers x_i, y_i, c_i (0 ≤ x_i, y_i ≤ 10^9, -10^6 ≤ c_i ≤ 10^6) — coordinates of the i-th point and its cost, respectively.
Output
In the first line print the maximum score Petya can achieve.
In the second line print four integers x_1, y_1, x_2, y_2 (0 ≤ x_1, y_1, x_2, y_2 ≤ 2 ⋅ 10^9, x_1 = y_1, x_2 = y_2, x_1 ≤ x_2) separated by spaces — the coordinates of the lower left and upper right corners of the square which Petya has to select in order to achieve the maximum score.
Examples
Input
6
0 0 2
1 0 -5
1 1 3
2 3 4
1 4 -4
3 1 -1
Output
4
1 1 3 3
Input
5
3 3 0
3 3 -3
0 2 -1
3 1 3
0 0 -2
Output
0
1 1 1 1
Note
The field corresponding to the first example: <image>
Submitted Solution:
```
def main():
import sys
import time
input = sys.stdin.buffer.readline
t0 = time.time()
N = int(input())
left = {}
right = {}
idx2val = set()
idx2val_r = set()
for _ in range(N):
x, y, c = map(int, input().split())
if x > y:
x, y = y, x
if x in left:
left[x].append((y, c))
else:
left[x] = [(y, c)]
if y in right:
right[y] += c
else:
right[y] = c
idx2val.add(x)
idx2val.add(y)
idx2val_r.add(y)
idx2val = sorted(list(idx2val))
idx2val_r = sorted(list(idx2val_r))
val2idx = {val: idx for idx, val in enumerate(idx2val_r)}
n = len(idx2val)
nr = len(right)
# N: 処理する区間の長さ
INF = 2 ** 40 - 1
LV = nr.bit_length()
N0 = 2 ** LV
data = [0] * (2 * N0)
lazy = [0] * (2 * N0)
def gindex(l, r):
L = (l + N0) >> 1
R = (r + N0) >> 1
lc = 0 if l & 1 else (L & -L).bit_length()
rc = 0 if r & 1 else (R & -R).bit_length()
for i in range(LV):
if rc <= i:
yield R
if L < R and lc <= i:
yield L
L >>= 1
R >>= 1
# 遅延伝搬処理
def propagates(*ids):
for i in reversed(ids):
v = lazy[i - 1]
if not v:
continue
lazy[2 * i - 1] += v
lazy[2 * i] += v
data[2 * i - 1] += v
data[2 * i] += v
lazy[i - 1] = 0
# 区間[l, r)にxを加算
def update(l, r, x):
*ids, = gindex(l, r)
propagates(*ids)
L = N0 + l
R = N0 + r
while L < R:
if R & 1:
R -= 1
lazy[R - 1] += x
data[R - 1] += x
if L & 1:
lazy[L - 1] += x
data[L - 1] += x
L += 1
L >>= 1
R >>= 1
for i in ids:
d1 = data[2 * i - 1]
d2 = data[2 * i]
if d1 > d2:
data[i-1] = d1
else:
data[i-1] = d2
# 区間[l, r)内の最小値を求める
def query(l, r):
propagates(*gindex(l, r))
L = N0 + l
R = N0 + r
s = -INF
while L < R:
if R & 1:
R -= 1
if data[R-1] > s:
s = data[R-1]
if L & 1:
if data[L-1] > s:
s = data[L-1]
L += 1
L >>= 1
R >>= 1
return s
ans = 0
ans_left = -1
cost = 0
for i in range(n):
val = idx2val[i]
cost -= val - idx2val[max(i - 1, 0)]
if val in right:
cost += right[val]
j = val2idx[val]
update(j+1, j+2, cost)
tmp = query(1, nr+1)
if tmp > ans:
ans = tmp
ans_left = 0
C = 0
val_left_prev = idx2val[0]
k = 0 if idx2val[0] not in right else 1
for i in range(1, n):
if time.time() - t0 > 5.5:
print(i, n)
exit()
val = idx2val[i]
val_prev = idx2val[i-1]
C += val - val_prev
if val not in left:
k += 1
continue
for y, c in left[val_left_prev]:
j = val2idx[y]
update(j+1, nr+1, -c)
val_left_prev = val
q_prev = query(k+1, nr+1)
tmp = q_prev + C
if val in right:
k += 1
if tmp > ans:
ans = tmp
ans_left = i
print(ans)
if ans_left == -1:
print(*[2*10**9] * 4)
else:
cost = 0
right = {}
for i in range(ans_left, n):
val = idx2val[i]
if val in left:
for y, c in left[val]:
if y in right:
right[y] += c
else:
right[y] = c
for i in range(ans_left, n):
val = idx2val[i]
if val in right:
cost += right[val]
cost -= val - idx2val[max(i - 1, ans_left)]
if cost == ans:
small = idx2val[ans_left]
large = idx2val[i]
print(small, small, large, large)
break
if __name__ == '__main__':
main()
``` | instruction | 0 | 80,022 | 23 | 160,044 |
No | output | 1 | 80,022 | 23 | 160,045 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
Imagine a board with n pins put into it, the i-th pin is located at (x_i, y_i). For simplicity, we will restrict the problem to the case where the pins are placed in vertices of a convex polygon.
Then, take a non-stretchable string of length l, and put it around all the pins. Place a pencil inside the string and draw a curve around the pins, trying to pull the string in every possible direction. The picture below shows an example of a string tied around the pins and pulled by a pencil (a point P).
<image>
Your task is to find an area inside this curve. Formally, for a given convex polygon S and a length l let's define a fiber shape F(S, l) as a set of points t such that the perimeter of the convex hull of S ∪ \\{t\} does not exceed l. Find an area of F(S, l).
Input
The first line contains two integers n and l (3 ≤ n ≤ 10^4; 1 ≤ l ≤ 8 ⋅ 10^5) — the number of vertices of the polygon S and the length of the string. Next n lines contain integers x_i and y_i (-10^5 ≤ x_i, y_i ≤ 10^5) — coordinates of polygon's vertices in counterclockwise order. All internal angles of the polygon are strictly less than π. The length l exceeds the perimeter of the polygon by at least 10^{-3}.
Output
Output a single floating-point number — the area of the fiber shape F(S, l). Your answer will be considered correct if its absolute or relative error doesn't exceed 10^{-6}.
Examples
Input
3 4
0 0
1 0
0 1
Output
3.012712585980357
Input
4 5
0 0
1 0
1 1
0 1
Output
5.682061989789656
Input
5 17
0 0
2 -1
3 0
4 3
-1 4
Output
37.719371276930820
Note
The following pictures illustrate the example tests.
<image> <image>
<image>
Submitted Solution:
```
print("I love 2020-2021 ICPC, NERC, Northern Eurasia so much")
``` | instruction | 0 | 80,180 | 23 | 160,360 |
No | output | 1 | 80,180 | 23 | 160,361 |
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 | 80,542 | 23 | 161,084 |
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 | 80,542 | 23 | 161,085 |
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 | 80,543 | 23 | 161,086 |
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 | 80,543 | 23 | 161,087 |
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 | 80,544 | 23 | 161,088 |
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 | 80,544 | 23 | 161,089 |
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 | 80,545 | 23 | 161,090 |
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 | 80,545 | 23 | 161,091 |
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
class Point:
def __init__(self, x, y):
self.x = x
self.y = y
def __repr__(self):
return "Point({}, {})".format(self.x, self.y)
def __eq__(self, other):
return self.x == other.x and self.y == other.y
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 __rmul__(self, other):
return Point(other*self.x, other*self.y)
class Line:
def __init__(self, a, b, c):
# ax+by+c=0
self.a = a
self.b = b
self.c = 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 perpendicular_from(self, P):
a = -self.b
b = self.a
c = -(a*P.x+b*P.y)
return Line(a, b, c)
def intersect(self, other):
det = self.a*other.b-self.b*other.a
if det == 0:
print("parallel!")
return None
x = (-other.b*self.c+self.b*other.c)/det
y = (other.a*self.c-self.a*other.c)/det
return Point(x, y)
def projection(self, P):
perp = self.perpendicular_from(P)
return self.intersect(perp)
n = int(input())
points = []
center = Point(Fraction(), Fraction())
for i in range(n):
row = input().split(" ")
cur = Point(Fraction(int(row[0])), Fraction(int(row[1])))
center += cur
points.append(cur)
center = Fraction(1, n) * center
#print(center)
nosym = []
for p in points:
psym = 2*center-p
if psym not in points:
nosym.append(p)
if len(nosym) == 0:
print(-1)
exit(0)
cnt = 0
p0 = nosym[0]
for p in nosym:
m = Fraction(1, 2)*(p+p0)
supp = Line.between_two_points(m, center)
line = supp.perpendicular_from(Point(Fraction(0), Fraction(0)))
projs = list(map(line.projection, nosym))
pcenter = line.projection(center)
ok = True
for pp in projs:
other = 2*pcenter-pp
if other not in projs:
ok = False
break
if ok:
cnt += 1
print(cnt)
``` | instruction | 0 | 80,546 | 23 | 161,092 |
No | output | 1 | 80,546 | 23 | 161,093 |
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:
```
n=int(input())
a=[]
ma=0
for i in range(n):
s=input()
z=s.split()
k1=int(z[0])-1
k2=int(z[1])-1
ma=max(k1,k2,ma)
a.append(s)
b=[[0]*(ma+1) for i in range(ma+1)]
for i in a:
z=i.split()
k1=int(z[0])-1
k2=int(z[1])-1
b[k1][k2]=1
a=[]
k=0
fl=True
for i in range(ma+1):
if b[i][i]==1 and fl:
k+=1
fl=False
for j in range(i+1,ma+1):
if b[i][j]==b[j][i] and b[j][i]!=0:
k+=2
if k<2:
print('-1')
else:
print(k)
``` | instruction | 0 | 80,547 | 23 | 161,094 |
No | output | 1 | 80,547 | 23 | 161,095 |
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:
```
n=int(input())
a=[[0]*2000 for i in range(2000)]
for i in range(n):
s=input().split()
k1=int(s[0])-1
k2=int(s[1])-1
a[k1][k2]=1
k=-1
for i in range(n):
for j in range(i,n):
if a[i][j]==a[j][i] and a[j][i]!=0:
k+=2
print(k)
``` | instruction | 0 | 80,548 | 23 | 161,096 |
No | output | 1 | 80,548 | 23 | 161,097 |
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 | 80,549 | 23 | 161,098 |
No | output | 1 | 80,549 | 23 | 161,099 |
Provide a correct Python 3 solution for this coding contest problem.
Write a program which computes the area of a shape represented by the following three lines:
$y = x^2$
$y = 0$
$x = 600$
It is clear that the area is $72000000$, if you use an integral you learn in high school. On the other hand, we can obtain an approximative area of the shape by adding up areas of many rectangles in the shape as shown in the following figure:
<image>
$f(x) = x^2$
The approximative area $s$ where the width of the rectangles is $d$ is:
area of rectangle where its width is $d$ and height is $f(d)$ $+$
area of rectangle where its width is $d$ and height is $f(2d)$ $+$
area of rectangle where its width is $d$ and height is $f(3d)$ $+$
...
area of rectangle where its width is $d$ and height is $f(600 - d)$
The more we decrease $d$, the higer-precision value which is close to $72000000$ we could obtain. Your program should read the integer $d$ which is a divisor of $600$, and print the area $s$.
Input
The input consists of several datasets. Each dataset consists of an integer $d$ in a line. The number of datasets is less than or equal to 20.
Output
For each dataset, print the area $s$ in a line.
Example
Input
20
10
Output
68440000
70210000 | instruction | 0 | 80,723 | 23 | 161,446 |
"Correct Solution:
```
while True:
try:
d=int(input())
z=0
for i in range(1,600//d):
x=d
y=(i*d)**2
z+=x*y
print(z)
except:
break
``` | output | 1 | 80,723 | 23 | 161,447 |
Provide a correct Python 3 solution for this coding contest problem.
Write a program which computes the area of a shape represented by the following three lines:
$y = x^2$
$y = 0$
$x = 600$
It is clear that the area is $72000000$, if you use an integral you learn in high school. On the other hand, we can obtain an approximative area of the shape by adding up areas of many rectangles in the shape as shown in the following figure:
<image>
$f(x) = x^2$
The approximative area $s$ where the width of the rectangles is $d$ is:
area of rectangle where its width is $d$ and height is $f(d)$ $+$
area of rectangle where its width is $d$ and height is $f(2d)$ $+$
area of rectangle where its width is $d$ and height is $f(3d)$ $+$
...
area of rectangle where its width is $d$ and height is $f(600 - d)$
The more we decrease $d$, the higer-precision value which is close to $72000000$ we could obtain. Your program should read the integer $d$ which is a divisor of $600$, and print the area $s$.
Input
The input consists of several datasets. Each dataset consists of an integer $d$ in a line. The number of datasets is less than or equal to 20.
Output
For each dataset, print the area $s$ in a line.
Example
Input
20
10
Output
68440000
70210000 | instruction | 0 | 80,724 | 23 | 161,448 |
"Correct Solution:
```
import sys
def f(x):
return x ** 2
def integral(d):
s = 0
for i in range(600 // d - 1):
s += f(d * (i + 1)) * d
return s
lines = sys.stdin.readlines()
for line in lines:
print(integral(int(line)))
``` | output | 1 | 80,724 | 23 | 161,449 |
Provide a correct Python 3 solution for this coding contest problem.
Write a program which computes the area of a shape represented by the following three lines:
$y = x^2$
$y = 0$
$x = 600$
It is clear that the area is $72000000$, if you use an integral you learn in high school. On the other hand, we can obtain an approximative area of the shape by adding up areas of many rectangles in the shape as shown in the following figure:
<image>
$f(x) = x^2$
The approximative area $s$ where the width of the rectangles is $d$ is:
area of rectangle where its width is $d$ and height is $f(d)$ $+$
area of rectangle where its width is $d$ and height is $f(2d)$ $+$
area of rectangle where its width is $d$ and height is $f(3d)$ $+$
...
area of rectangle where its width is $d$ and height is $f(600 - d)$
The more we decrease $d$, the higer-precision value which is close to $72000000$ we could obtain. Your program should read the integer $d$ which is a divisor of $600$, and print the area $s$.
Input
The input consists of several datasets. Each dataset consists of an integer $d$ in a line. The number of datasets is less than or equal to 20.
Output
For each dataset, print the area $s$ in a line.
Example
Input
20
10
Output
68440000
70210000 | instruction | 0 | 80,725 | 23 | 161,450 |
"Correct Solution:
```
while True :
try :
d = int(input())
except EOFError :
break
S = 0
for i in range(600//d) :
S += (i * d)**2 * d
print(S)
``` | output | 1 | 80,725 | 23 | 161,451 |
Provide a correct Python 3 solution for this coding contest problem.
Write a program which computes the area of a shape represented by the following three lines:
$y = x^2$
$y = 0$
$x = 600$
It is clear that the area is $72000000$, if you use an integral you learn in high school. On the other hand, we can obtain an approximative area of the shape by adding up areas of many rectangles in the shape as shown in the following figure:
<image>
$f(x) = x^2$
The approximative area $s$ where the width of the rectangles is $d$ is:
area of rectangle where its width is $d$ and height is $f(d)$ $+$
area of rectangle where its width is $d$ and height is $f(2d)$ $+$
area of rectangle where its width is $d$ and height is $f(3d)$ $+$
...
area of rectangle where its width is $d$ and height is $f(600 - d)$
The more we decrease $d$, the higer-precision value which is close to $72000000$ we could obtain. Your program should read the integer $d$ which is a divisor of $600$, and print the area $s$.
Input
The input consists of several datasets. Each dataset consists of an integer $d$ in a line. The number of datasets is less than or equal to 20.
Output
For each dataset, print the area $s$ in a line.
Example
Input
20
10
Output
68440000
70210000 | instruction | 0 | 80,726 | 23 | 161,452 |
"Correct Solution:
```
while 1:
try:
d=int(input())
ans=0
for i in range(600//d):
ans+=d*d*d*i*i
print(ans)
except:break
``` | output | 1 | 80,726 | 23 | 161,453 |
Provide a correct Python 3 solution for this coding contest problem.
Write a program which computes the area of a shape represented by the following three lines:
$y = x^2$
$y = 0$
$x = 600$
It is clear that the area is $72000000$, if you use an integral you learn in high school. On the other hand, we can obtain an approximative area of the shape by adding up areas of many rectangles in the shape as shown in the following figure:
<image>
$f(x) = x^2$
The approximative area $s$ where the width of the rectangles is $d$ is:
area of rectangle where its width is $d$ and height is $f(d)$ $+$
area of rectangle where its width is $d$ and height is $f(2d)$ $+$
area of rectangle where its width is $d$ and height is $f(3d)$ $+$
...
area of rectangle where its width is $d$ and height is $f(600 - d)$
The more we decrease $d$, the higer-precision value which is close to $72000000$ we could obtain. Your program should read the integer $d$ which is a divisor of $600$, and print the area $s$.
Input
The input consists of several datasets. Each dataset consists of an integer $d$ in a line. The number of datasets is less than or equal to 20.
Output
For each dataset, print the area $s$ in a line.
Example
Input
20
10
Output
68440000
70210000 | instruction | 0 | 80,727 | 23 | 161,454 |
"Correct Solution:
```
while(1):
try:
d = int(input())
except:
break
s = 0
w = d
while d < 600:
h = d * d
s += h * w
d += w
print(s)
``` | output | 1 | 80,727 | 23 | 161,455 |
Provide a correct Python 3 solution for this coding contest problem.
Write a program which computes the area of a shape represented by the following three lines:
$y = x^2$
$y = 0$
$x = 600$
It is clear that the area is $72000000$, if you use an integral you learn in high school. On the other hand, we can obtain an approximative area of the shape by adding up areas of many rectangles in the shape as shown in the following figure:
<image>
$f(x) = x^2$
The approximative area $s$ where the width of the rectangles is $d$ is:
area of rectangle where its width is $d$ and height is $f(d)$ $+$
area of rectangle where its width is $d$ and height is $f(2d)$ $+$
area of rectangle where its width is $d$ and height is $f(3d)$ $+$
...
area of rectangle where its width is $d$ and height is $f(600 - d)$
The more we decrease $d$, the higer-precision value which is close to $72000000$ we could obtain. Your program should read the integer $d$ which is a divisor of $600$, and print the area $s$.
Input
The input consists of several datasets. Each dataset consists of an integer $d$ in a line. The number of datasets is less than or equal to 20.
Output
For each dataset, print the area $s$ in a line.
Example
Input
20
10
Output
68440000
70210000 | instruction | 0 | 80,728 | 23 | 161,456 |
"Correct Solution:
```
import sys
for d in map(int, sys.stdin):
print(sum(d * cd ** 2 for cd in range(d, 600, d)))
``` | output | 1 | 80,728 | 23 | 161,457 |
Provide a correct Python 3 solution for this coding contest problem.
Write a program which computes the area of a shape represented by the following three lines:
$y = x^2$
$y = 0$
$x = 600$
It is clear that the area is $72000000$, if you use an integral you learn in high school. On the other hand, we can obtain an approximative area of the shape by adding up areas of many rectangles in the shape as shown in the following figure:
<image>
$f(x) = x^2$
The approximative area $s$ where the width of the rectangles is $d$ is:
area of rectangle where its width is $d$ and height is $f(d)$ $+$
area of rectangle where its width is $d$ and height is $f(2d)$ $+$
area of rectangle where its width is $d$ and height is $f(3d)$ $+$
...
area of rectangle where its width is $d$ and height is $f(600 - d)$
The more we decrease $d$, the higer-precision value which is close to $72000000$ we could obtain. Your program should read the integer $d$ which is a divisor of $600$, and print the area $s$.
Input
The input consists of several datasets. Each dataset consists of an integer $d$ in a line. The number of datasets is less than or equal to 20.
Output
For each dataset, print the area $s$ in a line.
Example
Input
20
10
Output
68440000
70210000 | instruction | 0 | 80,729 | 23 | 161,458 |
"Correct Solution:
```
while True:
try:
d = int(input())
except EOFError:
break
s = 0
for i in range(600//d):
s += d*(i*d)**2
print(s)
``` | output | 1 | 80,729 | 23 | 161,459 |
Provide a correct Python 3 solution for this coding contest problem.
Write a program which computes the area of a shape represented by the following three lines:
$y = x^2$
$y = 0$
$x = 600$
It is clear that the area is $72000000$, if you use an integral you learn in high school. On the other hand, we can obtain an approximative area of the shape by adding up areas of many rectangles in the shape as shown in the following figure:
<image>
$f(x) = x^2$
The approximative area $s$ where the width of the rectangles is $d$ is:
area of rectangle where its width is $d$ and height is $f(d)$ $+$
area of rectangle where its width is $d$ and height is $f(2d)$ $+$
area of rectangle where its width is $d$ and height is $f(3d)$ $+$
...
area of rectangle where its width is $d$ and height is $f(600 - d)$
The more we decrease $d$, the higer-precision value which is close to $72000000$ we could obtain. Your program should read the integer $d$ which is a divisor of $600$, and print the area $s$.
Input
The input consists of several datasets. Each dataset consists of an integer $d$ in a line. The number of datasets is less than or equal to 20.
Output
For each dataset, print the area $s$ in a line.
Example
Input
20
10
Output
68440000
70210000 | instruction | 0 | 80,730 | 23 | 161,460 |
"Correct Solution:
```
import sys
def calcIntegral(d:int)->float:
result = 0
for x in range(0,600,d):
result += d*x**2
return result
if __name__ == '__main__':
for tmpLine in sys.stdin:
d = int(tmpLine)
print(calcIntegral(d))
``` | output | 1 | 80,730 | 23 | 161,461 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
Write a program which computes the area of a shape represented by the following three lines:
$y = x^2$
$y = 0$
$x = 600$
It is clear that the area is $72000000$, if you use an integral you learn in high school. On the other hand, we can obtain an approximative area of the shape by adding up areas of many rectangles in the shape as shown in the following figure:
<image>
$f(x) = x^2$
The approximative area $s$ where the width of the rectangles is $d$ is:
area of rectangle where its width is $d$ and height is $f(d)$ $+$
area of rectangle where its width is $d$ and height is $f(2d)$ $+$
area of rectangle where its width is $d$ and height is $f(3d)$ $+$
...
area of rectangle where its width is $d$ and height is $f(600 - d)$
The more we decrease $d$, the higer-precision value which is close to $72000000$ we could obtain. Your program should read the integer $d$ which is a divisor of $600$, and print the area $s$.
Input
The input consists of several datasets. Each dataset consists of an integer $d$ in a line. The number of datasets is less than or equal to 20.
Output
For each dataset, print the area $s$ in a line.
Example
Input
20
10
Output
68440000
70210000
Submitted Solution:
```
import sys
def func(x):
fun = x*x
return fun
def cal(d):
s = 0
for i in range(1,int(600/d)):
s = s + d * func(i*d)
return s
for line in sys.stdin.readlines():
d = int(line)
print(cal(d))
``` | instruction | 0 | 80,731 | 23 | 161,462 |
Yes | output | 1 | 80,731 | 23 | 161,463 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
Write a program which computes the area of a shape represented by the following three lines:
$y = x^2$
$y = 0$
$x = 600$
It is clear that the area is $72000000$, if you use an integral you learn in high school. On the other hand, we can obtain an approximative area of the shape by adding up areas of many rectangles in the shape as shown in the following figure:
<image>
$f(x) = x^2$
The approximative area $s$ where the width of the rectangles is $d$ is:
area of rectangle where its width is $d$ and height is $f(d)$ $+$
area of rectangle where its width is $d$ and height is $f(2d)$ $+$
area of rectangle where its width is $d$ and height is $f(3d)$ $+$
...
area of rectangle where its width is $d$ and height is $f(600 - d)$
The more we decrease $d$, the higer-precision value which is close to $72000000$ we could obtain. Your program should read the integer $d$ which is a divisor of $600$, and print the area $s$.
Input
The input consists of several datasets. Each dataset consists of an integer $d$ in a line. The number of datasets is less than or equal to 20.
Output
For each dataset, print the area $s$ in a line.
Example
Input
20
10
Output
68440000
70210000
Submitted Solution:
```
ans_l = []
while True:
try:
d = int(input())
x_coordinate = -d
def height(x_coordinate):
return x_coordinate**2
ans = 0
for i in range(600//d):
x_coordinate += d
ans += d * height(x_coordinate)
ans_l.append(ans)
except:
break
print(*ans_l,sep='\n')
``` | instruction | 0 | 80,732 | 23 | 161,464 |
Yes | output | 1 | 80,732 | 23 | 161,465 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
Write a program which computes the area of a shape represented by the following three lines:
$y = x^2$
$y = 0$
$x = 600$
It is clear that the area is $72000000$, if you use an integral you learn in high school. On the other hand, we can obtain an approximative area of the shape by adding up areas of many rectangles in the shape as shown in the following figure:
<image>
$f(x) = x^2$
The approximative area $s$ where the width of the rectangles is $d$ is:
area of rectangle where its width is $d$ and height is $f(d)$ $+$
area of rectangle where its width is $d$ and height is $f(2d)$ $+$
area of rectangle where its width is $d$ and height is $f(3d)$ $+$
...
area of rectangle where its width is $d$ and height is $f(600 - d)$
The more we decrease $d$, the higer-precision value which is close to $72000000$ we could obtain. Your program should read the integer $d$ which is a divisor of $600$, and print the area $s$.
Input
The input consists of several datasets. Each dataset consists of an integer $d$ in a line. The number of datasets is less than or equal to 20.
Output
For each dataset, print the area $s$ in a line.
Example
Input
20
10
Output
68440000
70210000
Submitted Solution:
```
import sys
for l in sys.stdin:
d = int(l)
result = 0
for x in range(d, 600-d+1, d):
result += d*x**2
print(result)
``` | instruction | 0 | 80,733 | 23 | 161,466 |
Yes | output | 1 | 80,733 | 23 | 161,467 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
Write a program which computes the area of a shape represented by the following three lines:
$y = x^2$
$y = 0$
$x = 600$
It is clear that the area is $72000000$, if you use an integral you learn in high school. On the other hand, we can obtain an approximative area of the shape by adding up areas of many rectangles in the shape as shown in the following figure:
<image>
$f(x) = x^2$
The approximative area $s$ where the width of the rectangles is $d$ is:
area of rectangle where its width is $d$ and height is $f(d)$ $+$
area of rectangle where its width is $d$ and height is $f(2d)$ $+$
area of rectangle where its width is $d$ and height is $f(3d)$ $+$
...
area of rectangle where its width is $d$ and height is $f(600 - d)$
The more we decrease $d$, the higer-precision value which is close to $72000000$ we could obtain. Your program should read the integer $d$ which is a divisor of $600$, and print the area $s$.
Input
The input consists of several datasets. Each dataset consists of an integer $d$ in a line. The number of datasets is less than or equal to 20.
Output
For each dataset, print the area $s$ in a line.
Example
Input
20
10
Output
68440000
70210000
Submitted Solution:
```
while 1:
try:
d = int(input())
area = 0
for i in range(d, 600, d):
area += i ** 2 * d
print(area)
except:
break
``` | instruction | 0 | 80,734 | 23 | 161,468 |
Yes | output | 1 | 80,734 | 23 | 161,469 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
Write a program which computes the area of a shape represented by the following three lines:
$y = x^2$
$y = 0$
$x = 600$
It is clear that the area is $72000000$, if you use an integral you learn in high school. On the other hand, we can obtain an approximative area of the shape by adding up areas of many rectangles in the shape as shown in the following figure:
<image>
$f(x) = x^2$
The approximative area $s$ where the width of the rectangles is $d$ is:
area of rectangle where its width is $d$ and height is $f(d)$ $+$
area of rectangle where its width is $d$ and height is $f(2d)$ $+$
area of rectangle where its width is $d$ and height is $f(3d)$ $+$
...
area of rectangle where its width is $d$ and height is $f(600 - d)$
The more we decrease $d$, the higer-precision value which is close to $72000000$ we could obtain. Your program should read the integer $d$ which is a divisor of $600$, and print the area $s$.
Input
The input consists of several datasets. Each dataset consists of an integer $d$ in a line. The number of datasets is less than or equal to 20.
Output
For each dataset, print the area $s$ in a line.
Example
Input
20
10
Output
68440000
70210000
Submitted Solution:
```
while True:
try:
d = int(input())
except:
break
ans = 0
x = d
while x < 600:
ans += (x**2)*dx += d
print(ans)
``` | instruction | 0 | 80,735 | 23 | 161,470 |
No | output | 1 | 80,735 | 23 | 161,471 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
Write a program which computes the area of a shape represented by the following three lines:
$y = x^2$
$y = 0$
$x = 600$
It is clear that the area is $72000000$, if you use an integral you learn in high school. On the other hand, we can obtain an approximative area of the shape by adding up areas of many rectangles in the shape as shown in the following figure:
<image>
$f(x) = x^2$
The approximative area $s$ where the width of the rectangles is $d$ is:
area of rectangle where its width is $d$ and height is $f(d)$ $+$
area of rectangle where its width is $d$ and height is $f(2d)$ $+$
area of rectangle where its width is $d$ and height is $f(3d)$ $+$
...
area of rectangle where its width is $d$ and height is $f(600 - d)$
The more we decrease $d$, the higer-precision value which is close to $72000000$ we could obtain. Your program should read the integer $d$ which is a divisor of $600$, and print the area $s$.
Input
The input consists of several datasets. Each dataset consists of an integer $d$ in a line. The number of datasets is less than or equal to 20.
Output
For each dataset, print the area $s$ in a line.
Example
Input
20
10
Output
68440000
70210000
Submitted Solution:
```
while True:
d = int(input())
ans = 0
x = d
while x < 600:
ans += (x**2)*dx += d
print(ans)
``` | instruction | 0 | 80,736 | 23 | 161,472 |
No | output | 1 | 80,736 | 23 | 161,473 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
Write a program which computes the area of a shape represented by the following three lines:
$y = x^2$
$y = 0$
$x = 600$
It is clear that the area is $72000000$, if you use an integral you learn in high school. On the other hand, we can obtain an approximative area of the shape by adding up areas of many rectangles in the shape as shown in the following figure:
<image>
$f(x) = x^2$
The approximative area $s$ where the width of the rectangles is $d$ is:
area of rectangle where its width is $d$ and height is $f(d)$ $+$
area of rectangle where its width is $d$ and height is $f(2d)$ $+$
area of rectangle where its width is $d$ and height is $f(3d)$ $+$
...
area of rectangle where its width is $d$ and height is $f(600 - d)$
The more we decrease $d$, the higer-precision value which is close to $72000000$ we could obtain. Your program should read the integer $d$ which is a divisor of $600$, and print the area $s$.
Input
The input consists of several datasets. Each dataset consists of an integer $d$ in a line. The number of datasets is less than or equal to 20.
Output
For each dataset, print the area $s$ in a line.
Example
Input
20
10
Output
68440000
70210000
Submitted Solution:
```
while 1:
try:
d=int(input())
x=d
y=x**2
S=d*y
while S<=72000000:
x+=d
y=x**2
de=72000000-S
S+=d*y
if de<(S-72000000):
print(72000000-de)
else:
print(S)
except EOFError:
break
``` | instruction | 0 | 80,737 | 23 | 161,474 |
No | output | 1 | 80,737 | 23 | 161,475 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
Write a program which computes the area of a shape represented by the following three lines:
$y = x^2$
$y = 0$
$x = 600$
It is clear that the area is $72000000$, if you use an integral you learn in high school. On the other hand, we can obtain an approximative area of the shape by adding up areas of many rectangles in the shape as shown in the following figure:
<image>
$f(x) = x^2$
The approximative area $s$ where the width of the rectangles is $d$ is:
area of rectangle where its width is $d$ and height is $f(d)$ $+$
area of rectangle where its width is $d$ and height is $f(2d)$ $+$
area of rectangle where its width is $d$ and height is $f(3d)$ $+$
...
area of rectangle where its width is $d$ and height is $f(600 - d)$
The more we decrease $d$, the higer-precision value which is close to $72000000$ we could obtain. Your program should read the integer $d$ which is a divisor of $600$, and print the area $s$.
Input
The input consists of several datasets. Each dataset consists of an integer $d$ in a line. The number of datasets is less than or equal to 20.
Output
For each dataset, print the area $s$ in a line.
Example
Input
20
10
Output
68440000
70210000
Submitted Solution:
```
def integral(d):
print("d=%d" % d)
n = 600//d
print("n=%d" % n)
s = 0.0
for i in range(n):
s += (d*i)**2
return(s*d)
if __name__ == '__main__':
while True:
try:
d = int(input())
print(int(integral(d)))
except:
break
``` | instruction | 0 | 80,738 | 23 | 161,476 |
No | output | 1 | 80,738 | 23 | 161,477 |
Provide a correct Python 3 solution for this coding contest problem.
Let's write a program related to an unsolved math problem called "Happy End Problem". Create a program to find the smallest convex polygon formed by connecting exactly k points from the N points given on the plane. However, after being given the coordinates of N points, the question is given the number k of the angles of the convex polygon.
(Supplement: About the happy ending problem)
Place N points on the plane so that none of the three points are on the same straight line. At that time, no matter how you place the points, it is expected that if you select k points well, you will definitely be able to create a convex polygon with k corners. So far, it has been proved by 2006 that N = 3 for triangles, N = 5 for quadrilaterals, N = 9 for pentagons, and N = 17 for hexagons. There is also a prediction that N = 1 + 2k-2 for all k-sides above the triangle, but this has not yet been proven. This is a difficult problem that has been researched for 100 years.
This question has a nice name, "Happy End Problem". A friend of mathematicians named it after a man and a woman became friends while studying this issue and finally got married. It's romantic.
input
The input consists of one dataset. Input data is given in the following format.
N
x1 y1
::
xN yN
Q
k1
::
kQ
The number of points N (3 ≤ N ≤ 40) on the plane is given in the first line. The coordinates of each point are given in the following N lines. Each point is numbered from 1 to N in the order in which they are entered. xi and yi (-10000 ≤ xi, yi ≤ 10000) are integers representing the x and y coordinates of the i-th point, respectively. The positive direction of the x-axis shall be to the right, and the positive direction of the y-axis shall be upward.
The number of questions Q (1 ≤ Q ≤ N) is given in the following line. A question is given to the following Q line. ki (3 ≤ ki ≤ N) represents the number of corners of the convex polygon, which is the i-th question.
The input shall satisfy the following conditions.
* The coordinates of the input points are all different.
* None of the three points are on the same straight line.
* For each question, there is only one convex polygon with the smallest area, and the difference in area from the second smallest convex polygon is 0.0001 or more.
output
For each question, output all vertices of the convex polygon with the smallest area on one line. The number of vertices is output counterclockwise in order from the leftmost vertex among the bottom vertices of the convex polygon. Separate the vertex numbers with a single space. Do not print whitespace at the end of the line. However, if a convex polygon cannot be created, NA is output.
Example
Input
5
0 0
3 0
5 2
1 4
0 3
3
3
4
5
Output
1 4 5
1 2 4 5
1 2 3 4 5 | instruction | 0 | 80,741 | 23 | 161,482 |
"Correct Solution:
```
def triangle(a,b,c):
return cross(b - a, c - a) / 2
def cos(a, b):
return dot(a, b) / (abs(a) * abs(b))
def dot(a, b):
return a.real * b.real + a.imag * b.imag
def cross(a, b):
return a.real * b.imag - a.imag * b.real
def solve(xyi, xy):
# anti_clockwise_sort:sort(key=cos((1,0)(0,0)(xyk-xyi)),reverse=True)
xy = sorted(xy, key=lambda a:(a.real - xyi.real) / abs(a - xyi), reverse=True)
area = [[[(float('inf'),) for i in range(len(xy))] for j in range(len(xy))] for k in range(max(q) + 1)]
# triangle
for j in range(len(xy) - 1):
for k in range(j + 1, len(xy)):
area[3][j][k] = triangle(xyi, xy[j], xy[k]), (xyi, xy[j], xy[k])
# square,pentagon,,,,
for i in range(4, max(q) + 1):
for j in range(len(xy)):
for k in range(j + 1, len(xy)):
for s in range(k + 1, len(xy)):
if math.isinf(area[i - 1][j][k][0]):
continue
if triangle(xy[j], xy[k], xy[s]) <= 0:
continue #skip not convex polygon
tmp = area[3][k][s][0] + area[i - 1][j][k][0]
if not math.isnan(area[i][k][s][0]) and area[i][k][s][0] < tmp:
continue
area[i][k][s] = tmp, area[i - 1][j][k][1] + (xy[s],)
min_space = [(float('inf'),)] * (max(q) + 1)
for i in range(3, max(q) + 1):
min_space[i] = min([y for x in area[i] for y in x], key=operator.itemgetter(0))
return min_space
import sys
import operator
import math
f = sys.stdin
xy =[[int(i) for i in f.readline().split()] for _ in range(int(f.readline()))]
q = [int(f.readline()) for _ in range(int(f.readline()))]
xy = [x + y * 1j for x, y in xy]
id = {xyi:i+1 for i, xyi in enumerate(xy)}
xy.sort(key=operator.attrgetter('imag', 'real'))
min_space = [(float('inf'),) for i in range(max(q) + 1)]
while 2 < len(xy):
xyi = xy.pop(0)
min_space = [min(i, j, key=operator.itemgetter(0)) for i,j in zip(min_space,solve(xyi, xy))]
for qi in q:
if math.isinf(min_space[qi][0]):
print('NA')
else:
print(*[id[i] for i in min_space[qi][1]])
``` | output | 1 | 80,741 | 23 | 161,483 |
Provide a correct Python 3 solution for this coding contest problem.
Let's write a program related to an unsolved math problem called "Happy End Problem". Create a program to find the smallest convex polygon formed by connecting exactly k points from the N points given on the plane. However, after being given the coordinates of N points, the question is given the number k of the angles of the convex polygon.
(Supplement: About the happy ending problem)
Place N points on the plane so that none of the three points are on the same straight line. At that time, no matter how you place the points, it is expected that if you select k points well, you will definitely be able to create a convex polygon with k corners. So far, it has been proved by 2006 that N = 3 for triangles, N = 5 for quadrilaterals, N = 9 for pentagons, and N = 17 for hexagons. There is also a prediction that N = 1 + 2k-2 for all k-sides above the triangle, but this has not yet been proven. This is a difficult problem that has been researched for 100 years.
This question has a nice name, "Happy End Problem". A friend of mathematicians named it after a man and a woman became friends while studying this issue and finally got married. It's romantic.
input
The input consists of one dataset. Input data is given in the following format.
N
x1 y1
::
xN yN
Q
k1
::
kQ
The number of points N (3 ≤ N ≤ 40) on the plane is given in the first line. The coordinates of each point are given in the following N lines. Each point is numbered from 1 to N in the order in which they are entered. xi and yi (-10000 ≤ xi, yi ≤ 10000) are integers representing the x and y coordinates of the i-th point, respectively. The positive direction of the x-axis shall be to the right, and the positive direction of the y-axis shall be upward.
The number of questions Q (1 ≤ Q ≤ N) is given in the following line. A question is given to the following Q line. ki (3 ≤ ki ≤ N) represents the number of corners of the convex polygon, which is the i-th question.
The input shall satisfy the following conditions.
* The coordinates of the input points are all different.
* None of the three points are on the same straight line.
* For each question, there is only one convex polygon with the smallest area, and the difference in area from the second smallest convex polygon is 0.0001 or more.
output
For each question, output all vertices of the convex polygon with the smallest area on one line. The number of vertices is output counterclockwise in order from the leftmost vertex among the bottom vertices of the convex polygon. Separate the vertex numbers with a single space. Do not print whitespace at the end of the line. However, if a convex polygon cannot be created, NA is output.
Example
Input
5
0 0
3 0
5 2
1 4
0 3
3
3
4
5
Output
1 4 5
1 2 4 5
1 2 3 4 5 | instruction | 0 | 80,742 | 23 | 161,484 |
"Correct Solution:
```
def cross(z1, z2):
return z1.real * z2.imag - z1.imag * z2.real
def ccw(p1, p2, p3):
return cross(p2 - p1, p3 - p1) > 0
def triangle_area(p1, p2, p3):
# returns signed trangle area
return cross(p2 - p1, p3 - p1) / 2
from sys import stdin
file_input = stdin
N = int(file_input.readline())
P = []
M = {}
for i in range(1, N + 1):
x, y = map(int, file_input.readline().split())
z = x + y * 1j
P.append(z)
M[z] = i # point to id
Q = int(file_input.readline())
query = [int(file_input.readline()) for i in range(Q)]
ql = max(query) - 2
P.sort(key=lambda x: (x.imag, x.real))
max_area = 20000 * 20000
CP_area = [max_area for i in range(ql)]
CP_points = [None for i in range(ql)]
from cmath import phase
from itertools import combinations
for i, bp in enumerate(P[:-2], start=1):
tP = P[i:]
tP.sort(key=lambda x: phase(x - bp))
pn = N - i
tM = dict(zip(range(pn), tP)) # id to point
# making triangles
t_rec = [[None for k in range(pn)] for j in range(pn)]
for j, k in combinations(range(pn), 2):
pj, pk = tM[j], tM[k]
ta = triangle_area(bp, pj, pk)
t_rec[j][k] = [ta, [bp, pj, pk]]
if ta < CP_area[0]:
CP_area[0] = ta
CP_points[0] = [bp, pj, pk]
# making convex polygons
prev = t_rec.copy()
cur = [[None for k in range(pn)] for j in range(pn)]
for i in range(1, ql):
for j, k, s in combinations(range(pn), 3):
pre_cp = prev[j][k]
if pre_cp:
pj, pk, ps = tM[j], tM[k], tM[s]
if ccw(pj, pk, ps):
ta = pre_cp[0] + t_rec[k][s][0]
if not cur[k][s] or cur[k][s][0] > ta:
cur[k][s] = [ta, pre_cp[1] + [tM[s]]]
if ta < CP_area[i]:
CP_area[i] = ta
CP_points[i] = cur[k][s][1]
prev = cur.copy()
cur = [[None for k in range(pn)] for j in range(pn)]
# output
for q in query:
if CP_points[q-3]:
print(' '.join(map(lambda x: str(M[x]), CP_points[q-3])))
else:
print("NA")
``` | output | 1 | 80,742 | 23 | 161,485 |
Provide tags and a correct Python 3 solution for this coding contest problem.
At first, there was a legend related to the name of the problem, but now it's just a formal statement.
You are given n points a_1, a_2, ..., a_n on the OX axis. Now you are asked to find such an integer point x on OX axis that f_k(x) is minimal possible.
The function f_k(x) can be described in the following way:
* form a list of distances d_1, d_2, ..., d_n where d_i = |a_i - x| (distance between a_i and x);
* sort list d in non-descending order;
* take d_{k + 1} as a result.
If there are multiple optimal answers you can print any of them.
Input
The first line contains single integer T ( 1 ≤ T ≤ 2 ⋅ 10^5) — number of queries. Next 2 ⋅ T lines contain descriptions of queries. All queries are independent.
The first line of each query contains two integers n, k (1 ≤ n ≤ 2 ⋅ 10^5, 0 ≤ k < n) — the number of points and constant k.
The second line contains n integers a_1, a_2, ..., a_n (1 ≤ a_1 < a_2 < ... < a_n ≤ 10^9) — points in ascending order.
It's guaranteed that ∑{n} doesn't exceed 2 ⋅ 10^5.
Output
Print T integers — corresponding points x which have minimal possible value of f_k(x). If there are multiple answers you can print any of them.
Example
Input
3
3 2
1 2 5
2 1
1 1000000000
1 0
4
Output
3
500000000
4 | instruction | 0 | 80,886 | 23 | 161,772 |
Tags: binary search, brute force, greedy
Correct Solution:
```
# Legends Always Come Up with Solution
# Author: Manvir Singh
import os
from io import BytesIO, IOBase
import sys
from collections import defaultdict, deque, Counter
from math import sqrt, pi, ceil, log, inf, gcd, floor
from itertools import combinations,permutations
from bisect import *
from fractions import Fraction
def main():
for _ in range(int(input())):
n, k = map(int, input().split())
p = list(map(int, input().split()))
mi, x = inf, 0
for i in range(n - k):
if mi > (p[i + k] - p[i]):
mi = p[i + k] - p[i]
x = p[i] + (p[i + k] - p[i]) // 2
print(x)
# region fastio
BUFSIZE = 8192
class FastIO(IOBase):
newlines = 0
def __init__(self, file):
self._fd = file.fileno()
self.buffer = BytesIO()
self.writable = "x" in file.mode or "r" not in file.mode
self.write = self.buffer.write if self.writable else None
def read(self):
while True:
b = os.read(self._fd, max(os.fstat(self._fd).st_size, BUFSIZE))
if not b:
break
ptr = self.buffer.tell()
self.buffer.seek(0, 2), self.buffer.write(b), self.buffer.seek(ptr)
self.newlines = 0
return self.buffer.read()
def readline(self):
while self.newlines == 0:
b = os.read(self._fd, max(os.fstat(self._fd).st_size, BUFSIZE))
self.newlines = b.count(b"\n") + (not b)
ptr = self.buffer.tell()
self.buffer.seek(0, 2), self.buffer.write(b), self.buffer.seek(ptr)
self.newlines -= 1
return self.buffer.readline()
def flush(self):
if self.writable:
os.write(self._fd, self.buffer.getvalue())
self.buffer.truncate(0), self.buffer.seek(0)
class IOWrapper(IOBase):
def __init__(self, file):
self.buffer = FastIO(file)
self.flush = self.buffer.flush
self.writable = self.buffer.writable
self.write = lambda s: self.buffer.write(s.encode("ascii"))
self.read = lambda: self.buffer.read().decode("ascii")
self.readline = lambda: self.buffer.readline().decode("ascii")
sys.stdin, sys.stdout = IOWrapper(sys.stdin), IOWrapper(sys.stdout)
input = lambda: sys.stdin.readline().rstrip("\r\n")
if __name__ == "__main__":
main()
``` | output | 1 | 80,886 | 23 | 161,773 |
Provide tags and a correct Python 3 solution for this coding contest problem.
At first, there was a legend related to the name of the problem, but now it's just a formal statement.
You are given n points a_1, a_2, ..., a_n on the OX axis. Now you are asked to find such an integer point x on OX axis that f_k(x) is minimal possible.
The function f_k(x) can be described in the following way:
* form a list of distances d_1, d_2, ..., d_n where d_i = |a_i - x| (distance between a_i and x);
* sort list d in non-descending order;
* take d_{k + 1} as a result.
If there are multiple optimal answers you can print any of them.
Input
The first line contains single integer T ( 1 ≤ T ≤ 2 ⋅ 10^5) — number of queries. Next 2 ⋅ T lines contain descriptions of queries. All queries are independent.
The first line of each query contains two integers n, k (1 ≤ n ≤ 2 ⋅ 10^5, 0 ≤ k < n) — the number of points and constant k.
The second line contains n integers a_1, a_2, ..., a_n (1 ≤ a_1 < a_2 < ... < a_n ≤ 10^9) — points in ascending order.
It's guaranteed that ∑{n} doesn't exceed 2 ⋅ 10^5.
Output
Print T integers — corresponding points x which have minimal possible value of f_k(x). If there are multiple answers you can print any of them.
Example
Input
3
3 2
1 2 5
2 1
1 1000000000
1 0
4
Output
3
500000000
4 | instruction | 0 | 80,888 | 23 | 161,776 |
Tags: binary search, brute force, greedy
Correct Solution:
```
import sys
input=sys.stdin.readline
for _ in range(int(input())):
n,k=map(int,input().split());A=list(map(int,input().split()));ans=10**10
if n==1:print(A[0])
else:
for i in range(n-k):
if ans>A[i+k]-A[i]:
m=i;ans=A[i+k]-A[i]
print((A[m+k]+A[m])//2)
``` | output | 1 | 80,888 | 23 | 161,777 |
Provide tags and a correct Python 3 solution for this coding contest problem.
At first, there was a legend related to the name of the problem, but now it's just a formal statement.
You are given n points a_1, a_2, ..., a_n on the OX axis. Now you are asked to find such an integer point x on OX axis that f_k(x) is minimal possible.
The function f_k(x) can be described in the following way:
* form a list of distances d_1, d_2, ..., d_n where d_i = |a_i - x| (distance between a_i and x);
* sort list d in non-descending order;
* take d_{k + 1} as a result.
If there are multiple optimal answers you can print any of them.
Input
The first line contains single integer T ( 1 ≤ T ≤ 2 ⋅ 10^5) — number of queries. Next 2 ⋅ T lines contain descriptions of queries. All queries are independent.
The first line of each query contains two integers n, k (1 ≤ n ≤ 2 ⋅ 10^5, 0 ≤ k < n) — the number of points and constant k.
The second line contains n integers a_1, a_2, ..., a_n (1 ≤ a_1 < a_2 < ... < a_n ≤ 10^9) — points in ascending order.
It's guaranteed that ∑{n} doesn't exceed 2 ⋅ 10^5.
Output
Print T integers — corresponding points x which have minimal possible value of f_k(x). If there are multiple answers you can print any of them.
Example
Input
3
3 2
1 2 5
2 1
1 1000000000
1 0
4
Output
3
500000000
4 | instruction | 0 | 80,889 | 23 | 161,778 |
Tags: binary search, brute force, greedy
Correct Solution:
```
from sys import stdin, stdout
T = int(input())
#s = input()
for i in range(T):
N,K = [int(x) for x in stdin.readline().split()]
arr = [int(x) for x in stdin.readline().split()]
arr.sort()
res = 99999999999
x = 0
for i in range(N):
if i+K>=N:
break
else:
A = arr[i]
B = arr[i+K]
d = B - A
if d%2==1:
d = d//2 + 1
else:
d = d//2
if d<res:
res = d
x = (A+B)//2
print(x)
``` | output | 1 | 80,889 | 23 | 161,779 |
Provide tags and a correct Python 3 solution for this coding contest problem.
At first, there was a legend related to the name of the problem, but now it's just a formal statement.
You are given n points a_1, a_2, ..., a_n on the OX axis. Now you are asked to find such an integer point x on OX axis that f_k(x) is minimal possible.
The function f_k(x) can be described in the following way:
* form a list of distances d_1, d_2, ..., d_n where d_i = |a_i - x| (distance between a_i and x);
* sort list d in non-descending order;
* take d_{k + 1} as a result.
If there are multiple optimal answers you can print any of them.
Input
The first line contains single integer T ( 1 ≤ T ≤ 2 ⋅ 10^5) — number of queries. Next 2 ⋅ T lines contain descriptions of queries. All queries are independent.
The first line of each query contains two integers n, k (1 ≤ n ≤ 2 ⋅ 10^5, 0 ≤ k < n) — the number of points and constant k.
The second line contains n integers a_1, a_2, ..., a_n (1 ≤ a_1 < a_2 < ... < a_n ≤ 10^9) — points in ascending order.
It's guaranteed that ∑{n} doesn't exceed 2 ⋅ 10^5.
Output
Print T integers — corresponding points x which have minimal possible value of f_k(x). If there are multiple answers you can print any of them.
Example
Input
3
3 2
1 2 5
2 1
1 1000000000
1 0
4
Output
3
500000000
4 | instruction | 0 | 80,890 | 23 | 161,780 |
Tags: binary search, brute force, greedy
Correct Solution:
```
import sys
input = sys.stdin.readline
T = int(input())
for _ in range(T):
N, K = map(int, input().split())
A = [int(a) for a in input().split()]
B = [A[i+K]-A[K] for i in range(N-K)]
mi = 10**20
mx = -1
for i in range(N-K):
if A[i+K]-A[i] < mi:
mi = A[i+K]-A[i]
mx = (A[i+K]+A[i]) // 2
print(mx)
``` | output | 1 | 80,890 | 23 | 161,781 |
Provide tags and a correct Python 3 solution for this coding contest problem.
At first, there was a legend related to the name of the problem, but now it's just a formal statement.
You are given n points a_1, a_2, ..., a_n on the OX axis. Now you are asked to find such an integer point x on OX axis that f_k(x) is minimal possible.
The function f_k(x) can be described in the following way:
* form a list of distances d_1, d_2, ..., d_n where d_i = |a_i - x| (distance between a_i and x);
* sort list d in non-descending order;
* take d_{k + 1} as a result.
If there are multiple optimal answers you can print any of them.
Input
The first line contains single integer T ( 1 ≤ T ≤ 2 ⋅ 10^5) — number of queries. Next 2 ⋅ T lines contain descriptions of queries. All queries are independent.
The first line of each query contains two integers n, k (1 ≤ n ≤ 2 ⋅ 10^5, 0 ≤ k < n) — the number of points and constant k.
The second line contains n integers a_1, a_2, ..., a_n (1 ≤ a_1 < a_2 < ... < a_n ≤ 10^9) — points in ascending order.
It's guaranteed that ∑{n} doesn't exceed 2 ⋅ 10^5.
Output
Print T integers — corresponding points x which have minimal possible value of f_k(x). If there are multiple answers you can print any of them.
Example
Input
3
3 2
1 2 5
2 1
1 1000000000
1 0
4
Output
3
500000000
4 | instruction | 0 | 80,891 | 23 | 161,782 |
Tags: binary search, brute force, greedy
Correct Solution:
```
t = int(input())
Ans = []
for _ in range(t):
n,k = map(int,input().split())
A = list(map(int,input().split()))
mini = 100000000000
for i in range(n-k):
y1 = (-A[i]+A[i+k]-1)/2
y2 = (-A[i]+A[i+k])/2
if float.is_integer(y1):
if mini > y1+1:
ans = A[i] + y1
mini = y1 + 1
elif float.is_integer(y2):
if mini > y2:
ans = A[i] + y2
mini = y2
Ans.append(int(ans))
print(*Ans,sep = "\n")
``` | output | 1 | 80,891 | 23 | 161,783 |
Provide tags and a correct Python 3 solution for this coding contest problem.
At first, there was a legend related to the name of the problem, but now it's just a formal statement.
You are given n points a_1, a_2, ..., a_n on the OX axis. Now you are asked to find such an integer point x on OX axis that f_k(x) is minimal possible.
The function f_k(x) can be described in the following way:
* form a list of distances d_1, d_2, ..., d_n where d_i = |a_i - x| (distance between a_i and x);
* sort list d in non-descending order;
* take d_{k + 1} as a result.
If there are multiple optimal answers you can print any of them.
Input
The first line contains single integer T ( 1 ≤ T ≤ 2 ⋅ 10^5) — number of queries. Next 2 ⋅ T lines contain descriptions of queries. All queries are independent.
The first line of each query contains two integers n, k (1 ≤ n ≤ 2 ⋅ 10^5, 0 ≤ k < n) — the number of points and constant k.
The second line contains n integers a_1, a_2, ..., a_n (1 ≤ a_1 < a_2 < ... < a_n ≤ 10^9) — points in ascending order.
It's guaranteed that ∑{n} doesn't exceed 2 ⋅ 10^5.
Output
Print T integers — corresponding points x which have minimal possible value of f_k(x). If there are multiple answers you can print any of them.
Example
Input
3
3 2
1 2 5
2 1
1 1000000000
1 0
4
Output
3
500000000
4 | instruction | 0 | 80,892 | 23 | 161,784 |
Tags: binary search, brute force, greedy
Correct Solution:
```
import sys
t=int(sys.stdin.readline())
for i in range(t):
n,k=map(int,sys.stdin.readline().split())
a=list(map(int,sys.stdin.readline().split()))
q=a[k]-a[0]
an=a[0]+(a[k]-a[0])//2
for j in range(1,n-k):
p=a[j+k]-a[j]
if p<q:
q=p
an=a[j]+p//2
print(an)
``` | output | 1 | 80,892 | 23 | 161,785 |
Provide tags and a correct Python 3 solution for this coding contest problem.
At first, there was a legend related to the name of the problem, but now it's just a formal statement.
You are given n points a_1, a_2, ..., a_n on the OX axis. Now you are asked to find such an integer point x on OX axis that f_k(x) is minimal possible.
The function f_k(x) can be described in the following way:
* form a list of distances d_1, d_2, ..., d_n where d_i = |a_i - x| (distance between a_i and x);
* sort list d in non-descending order;
* take d_{k + 1} as a result.
If there are multiple optimal answers you can print any of them.
Input
The first line contains single integer T ( 1 ≤ T ≤ 2 ⋅ 10^5) — number of queries. Next 2 ⋅ T lines contain descriptions of queries. All queries are independent.
The first line of each query contains two integers n, k (1 ≤ n ≤ 2 ⋅ 10^5, 0 ≤ k < n) — the number of points and constant k.
The second line contains n integers a_1, a_2, ..., a_n (1 ≤ a_1 < a_2 < ... < a_n ≤ 10^9) — points in ascending order.
It's guaranteed that ∑{n} doesn't exceed 2 ⋅ 10^5.
Output
Print T integers — corresponding points x which have minimal possible value of f_k(x). If there are multiple answers you can print any of them.
Example
Input
3
3 2
1 2 5
2 1
1 1000000000
1 0
4
Output
3
500000000
4 | instruction | 0 | 80,893 | 23 | 161,786 |
Tags: binary search, brute force, greedy
Correct Solution:
```
import sys
input=sys.stdin.readline
t=int(input())
for _ in range(t):
n,k=map(int,input().split())
a=list(map(int,input().split()))
d=10**18
x=-1
for i in range(n-k):
if abs(a[i+k]-a[i])<d:
d=abs(a[i+k]-a[i])
x=a[i]+(a[i+k]-a[i])//2
print(x)
``` | output | 1 | 80,893 | 23 | 161,787 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
At first, there was a legend related to the name of the problem, but now it's just a formal statement.
You are given n points a_1, a_2, ..., a_n on the OX axis. Now you are asked to find such an integer point x on OX axis that f_k(x) is minimal possible.
The function f_k(x) can be described in the following way:
* form a list of distances d_1, d_2, ..., d_n where d_i = |a_i - x| (distance between a_i and x);
* sort list d in non-descending order;
* take d_{k + 1} as a result.
If there are multiple optimal answers you can print any of them.
Input
The first line contains single integer T ( 1 ≤ T ≤ 2 ⋅ 10^5) — number of queries. Next 2 ⋅ T lines contain descriptions of queries. All queries are independent.
The first line of each query contains two integers n, k (1 ≤ n ≤ 2 ⋅ 10^5, 0 ≤ k < n) — the number of points and constant k.
The second line contains n integers a_1, a_2, ..., a_n (1 ≤ a_1 < a_2 < ... < a_n ≤ 10^9) — points in ascending order.
It's guaranteed that ∑{n} doesn't exceed 2 ⋅ 10^5.
Output
Print T integers — corresponding points x which have minimal possible value of f_k(x). If there are multiple answers you can print any of them.
Example
Input
3
3 2
1 2 5
2 1
1 1000000000
1 0
4
Output
3
500000000
4
Submitted Solution:
```
'''https://codeforces.com/contest/1175/problem/C'''
from sys import stdin
def solve(l, n, k):
min_d = l[n - 1]
min_idx = 0
for i in range(n - k):
dist = l[i + k] - l[i]
if dist < min_d:
min_d = dist
min_idx = i
res = l[min_idx] + (min_d // 2)
return res
if __name__ == "__main__":
t = int(input())
res = []
for _ in range(t):
n, k = map(int, stdin.readline().split())
l = [int(x) for x in stdin.readline().split()]
res.append(solve(l, n, k))
print(*res)
``` | instruction | 0 | 80,896 | 23 | 161,792 |
Yes | output | 1 | 80,896 | 23 | 161,793 |
Provide tags and a correct Python 3 solution for this coding contest problem.
At the foot of Liyushan Mountain, n tents will be carefully arranged to provide accommodation for those who are willing to experience the joy of approaching nature, the tranquility of the night, and the bright starry sky.
The i-th tent is located at the point of (x_i, y_i) and has a weight of w_i. A tent is important if and only if both x_i and y_i are even. You need to remove some tents such that for each remaining important tent (x, y), there do not exist 3 other tents (x'_1, y'_1), (x'_2, y'_2) and (x'_3, y'_3) such that both conditions are true:
1. |x'_j-x|, |y'_j - y|≤ 1 for all j ∈ \{1, 2, 3\}, and
2. these four tents form a parallelogram (or a rectangle) and one of its sides is parallel to the x-axis.
Please maximize the sum of the weights of the tents that are not removed. Print the maximum value.
Input
The first line contains a single integer n (1≤ n≤ 1 000), representing the number of tents.
Each of the next n lines contains three integers x_i, y_i and w_i (-10^9≤ x_i,y_i ≤ 10^9, 1≤ w_i≤ 10^9), representing the coordinate of the i-th tent and its weight. No two tents are located at the same point.
Output
A single integer — the maximum sum of the weights of the remaining tents.
Examples
Input
5
0 0 4
0 1 5
1 0 3
1 1 1
-1 1 2
Output
12
Input
32
2 2 1
2 3 1
3 2 1
3 3 1
2 6 1
2 5 1
3 6 1
3 5 1
2 8 1
2 9 1
1 8 1
1 9 1
2 12 1
2 11 1
1 12 1
1 11 1
6 2 1
7 2 1
6 3 1
5 3 1
6 6 1
7 6 1
5 5 1
6 5 1
6 8 1
5 8 1
6 9 1
7 9 1
6 12 1
5 12 1
6 11 1
7 11 1
Output
24
Note
Here is an illustration of the second example. Black triangles indicate the important tents. This example also indicates all 8 forbidden patterns.
<image> | instruction | 0 | 81,061 | 23 | 162,122 |
Tags: constructive algorithms, flows, graphs
Correct Solution:
```
import sys,io,os
try:Z=io.BytesIO(os.read(0,os.fstat(0).st_size)).readline
except:Z=lambda:sys.stdin.readline().encode()
Y=lambda:map(int,Z().split())
INF=float("inf");big=10**13
class D:
def __init__(self, n):
self.lvl = [0] * n
self.ptr = [0] * n
self.q = [0] * n
self.adj = [[] for _ in range(n)]
def add(self, a, b, c, rcap=0):
self.adj[a].append([b, len(self.adj[b]), c, 0])
self.adj[b].append([a, len(self.adj[a]) - 1, rcap, 0])
def dfs(self, v, t, f):
if v == t or not f:
return f
for i in range(self.ptr[v], len(self.adj[v])):
e = self.adj[v][i]
if self.lvl[e[0]] == self.lvl[v] + 1:
p = self.dfs(e[0], t, min(f, e[2] - e[3]))
if p:
self.adj[v][i][3] += p
self.adj[e[0]][e[1]][3] -= p
return p
self.ptr[v] += 1
return 0
def calc(self, s, t):
flow, self.q[0] = 0, s
for l in range(31):
while True:
self.lvl, self.ptr = [0] * len(self.q), [0] * len(self.q)
qi, qe, self.lvl[s] = 0, 1, 1
while qi < qe and not self.lvl[t]:
v = self.q[qi]
qi += 1
for e in self.adj[v]:
if not self.lvl[e[0]] and (e[2] - e[3]) >> (30 - l):
self.q[qe] = e[0]
qe += 1
self.lvl[e[0]] = self.lvl[v] + 1
p = self.dfs(s, t, INF)
while p:
flow += p
p = self.dfs(s, t, INF)
if not self.lvl[t]:
break
return flow
r=lambda x,y:(y&1)*2+1-((x+y)&1)
n=int(Z());p={};d=D(2*n+2);w=[0]*n
for i in range(n):x,y,z=Y();w[i]=z;p[(x,y)]=i
for x,y in p:
i=p[(x,y)];v=r(x,y);d.add(i,i+n,w[i])
if v<1:
d.add(2*n,i,big)
if(x+1,y)in p:d.add(i+n,p[(x+1,y)],big)
if(x-1,y)in p:d.add(i+n,p[(x-1,y)],big)
elif v<2:
if(x,y+1)in p:d.add(i+n,p[(x,y+1)],big)
if(x,y-1)in p:d.add(i+n,p[(x,y-1)],big)
elif v<3:
if(x+1,y)in p:d.add(i+n,p[(x+1,y)],big)
if(x-1,y)in p:d.add(i+n,p[(x-1,y)],big)
else:d.add(i+n,2*n+1,big)
print(sum(w)-d.calc(2*n,2*n+1))
``` | output | 1 | 81,061 | 23 | 162,123 |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.