problem_id
stringclasses 100
values | submission_id
stringlengths 10
10
| status
stringclasses 2
values | code
stringlengths 6
806
|
|---|---|---|---|
p02556
|
s471150042
|
Wrong Answer
|
N = int(input())
xy = [list(map(int, input().split())) for _ in range(N)]
kyori = []
for i in range(N):
tmp1 = xy[i][0] + xy[i][1]
tmp2 = abs(xy[i][0] - xy[i][1])
kyori.append((i, tmp1, tmp2))
kyori.sort(key=lambda x: (x[1], x[2]))
print(abs(xy[kyori[0][0]][0] - xy[kyori[-1][0]][0]) + abs(xy[kyori[0][0]][1] - xy[kyori[-1][0]][1]))
|
p02556
|
s960710552
|
Wrong Answer
|
import sys
input = lambda: sys.stdin.readline().rstrip("\r\n")
n = int(input())
xy = [[] for _ in range(n)]
f = []
for i in range(n):
x, y = map(int, input().split())
f.append(x + y)
f.append(abs(-x - y))
xy[i].append(x + y)
xy[i].append(abs(-x - y))
print(max(f) - min(f))
|
p02556
|
s653067749
|
Wrong Answer
|
beforex=0
beforey=0
sum=0
for i in range(int(input())):
xy=list(map(int,input().split()))
if i == 0:
beforex=xy[0]
beforey=xy[1]
sum=max(sum,abs(beforex-xy[0])+abs(beforey-xy[1]))
beforex=xy[0]
beforey=xy[1]
print(sum)
|
p02556
|
s461037170
|
Wrong Answer
|
N = int(input())
XY_max = -10**10
XY_min = 10**10
YX_max = -10**10
YX_min = 10**10
for _ in range(N):
x,y = map(int, input().split())
XY_max = max(XY_max,x+y)
XY_min = min(XY_min,x+y)
YX_max = max(YX_max,x-y)
YX_min = max(YX_min,x-y)
print(max(XY_max-XY_min,YX_max-YX_min))
|
p02556
|
s237921262
|
Wrong Answer
|
n=int(input())
X=[]
Y=[]
for i in range(n):
x,y=map(int,input().split())
X.append(x+y)
Y.append(x-y)
max_x=max(X)
min_x=min(X)
max_y=max(Y)
min_y=min(Y)
l=max(max_x-min_x,max_y-min_y)
P=[(min(X)+l//2,min(Y)+l//2),(min(X)+l//2,max(Y)-l//2),
(max(X)-l//2,min(Y)+l//2),(max(X)-l//2,max(Y)-l//2)]
ans=0
print((max_x-min_y)//2)
|
p02556
|
s553445815
|
Wrong Answer
|
n = int(input())
l=[]
for i in range(n):
l.append(list(map(int,list(input().split()))))
l.sort()
c=0
print(l)
for i in range(n):
t = abs(l[i][0]-l[0][0])+abs(l[i][1]-l[0][1])
if t>c:
c=t
print(c)
|
p02556
|
s010791932
|
Wrong Answer
|
n=int(input())
minman=(10**9)*2
maxman=0
for i in range(n):
x,y=map(int, input().split())
ab=x+y
if ab< minman:
minman=ab
if maxman<ab:
maxman=ab
print(maxman-minman)
|
p02556
|
s409207501
|
Wrong Answer
|
from sys import stdin
readline = stdin.readline
N = int(readline())
xy = [tuple(map(int, readline().split())) for _ in range(N)]
xy.sort()
c = set(xy[:750])
c = c | set(xy[-750:])
xy.sort(key=lambda x: x[1])
c = c | set(xy[:750])
c = c | set(xy[-750:])
c = list(c)
result = 0
for i in range(len(c)):
for j in range(i + 1, len(c)):
result = max(result, abs(c[i][0] - c[j][0]) + abs(c[i][1] - c[j][1]))
print(result)
|
p02556
|
s414391722
|
Wrong Answer
|
n = int(input())
l = []
for i in range(n):
n,m = map(int,input().split())
l.append(n+m)
print (max(l)-min(l))
|
p02556
|
s305897062
|
Wrong Answer
|
n = int(input())
cd = [[] for _ in range(n)]
for i in range(n):
x, y = map(int,input().split())
cd[i].append(x+y)
cd[i].append(x-y)
md = 0
for i in range(n-1):
for j in range(i+1,n):
d1 = abs(cd[i][0] - cd[j][0])
d2 = abs(cd[i][1] - cd[j][1])
md = max(d1, d2)
print(md)
|
p02556
|
s438196077
|
Wrong Answer
|
from itertools import combinations
N = int(input())
p = []
for _ in range(N):
x, y = map(int, input().split())
p.append((x, y))
px = sorted(p, key=lambda i: i[0])
py = sorted(p, key=lambda i: i[1])
res = 0
for p1, p2 in combinations([px[0], px[-1], py[0], py[-1]], 2):
res = max(res, abs(p1[0] - p2[0]) + abs(p1[1] - p2[1]))
print(res)
|
p02556
|
s051009876
|
Wrong Answer
|
n = int(input())
maxsum = -float('inf')
minsum = float('inf')
maxdif = -float('inf')
mindif = float('inf')
for i in range(n):
x, y = map(int, input().split())
trysum = x + y
trydif = x - y
if trysum >= maxsum:
maxsum = trysum
if trysum <= minsum:
minsum = trysum
if trydif >= maxdif:
maxdif = trydif
if trydif <= minsum:
mindif = trydif
print(max(maxsum - minsum, maxdif - mindif))
|
p02556
|
s425088000
|
Wrong Answer
|
N = int(input())
P = [[int(_) for _ in input().split()] for n in range(N)]
X = []
Y = []
for x, y in P:
X.append(x)
Y.append(y)
mx = min(X) + max(X) // 2
my = min(Y) + max(Y) // 2
Q = []
for x, y in P:
x, y = x-mx, y-my
Q.append((x+y, x-y))
ans = 0
for x, y in Q:
ans = max(ans, abs(x) + abs(y))
print(ans)
|
p02556
|
s445914485
|
Wrong Answer
|
Row=int(input())
X=[]
Y=[]
for i in range(Row):
n,a=input().split()
X.append(int(n))
Y.append(int(a))
A=[]
B=[]
for i in range(len(X)):
A.append(X[i]-Y[i])
B.append(X[i]+Y[i])
maxmax1=0
maxmax2=0
minmin1=10**10
minmin2=10**10
for i in range(len(A)):
maxmax1=max(maxmax1,A[i])
minmin1=min(minmin1,A[i])
for i in range(len(B)):
maxmax2=max(maxmax2,B[i])
minmin2=min(minmin2,B[i])
print(max((maxmax1-minmin1),(maxmax2-minmin2)))
|
p02556
|
s720824883
|
Wrong Answer
|
n = int(input())
arr = []
for i in range(n):
arr.append(tuple(map(int, input().split())))
arr.sort(key = sum)
mx = max(arr, key = sum)
mn = min(arr, key = sum)
print(abs(mx[0]-mn[0]) + abs(mx[1] - mn[0]))
|
p02556
|
s907064473
|
Wrong Answer
|
n = int(input())
xy = list(list(map(int,input().split())) for _ in range(n))
l = []
for i in range(n):
l.append(xy[i][0]+xy[i][1])
d = abs(abs(xy[l.index(max(l))][0])-abs(xy[l.index(min(l))][0]))+abs(abs(xy[l.index(max(l))][1])-abs(xy[l.index(min(l))][1]))
print(d)
|
p02556
|
s031490621
|
Wrong Answer
|
n=int(input())
l=[list(map(int,input().split())) for i in range(n)]
num=[i[0]+i[1] for i in l]
mi=num.index(min(num))
ma=num.index(max(num))
a=abs(l[ma][0]-l[mi][0])
b=abs(l[ma][1]-l[mi][1])
print(a+b)
|
p02556
|
s143390983
|
Wrong Answer
|
import sys
input = sys.stdin.readline
sys.setrecursionlimit(10 ** 7)
n = int(input())
xy = [0] * n
xy_plus_max = 0
xy_plus_min = 10 ** 10
xy_minus_max = 0
xy_minus_min = 10 ** 10
for i in range(n):
x, y = map(int, input().split())
xy_plus_max = max(xy_plus_max, abs(x + y))
xy_plus_min = min(xy_plus_min, abs(x + y))
xy_minus_max = max(xy_minus_max, abs(x - y))
xy_minus_min = min(xy_minus_min, abs(x - y))
print(max(xy_plus_max - xy_plus_min, xy_minus_max - xy_minus_min))
|
p02556
|
s358068304
|
Wrong Answer
|
n = int(input())
s = []
for i in range(n):
x = list(map(int, input().split()))
s.append(x)
t = sorted(s)
u = sorted(s, key=lambda x: x[1])
res = 0
for X in [t[0], u[0], t[-1], u[-1], t[n // 2], u[n // 2], t[-1 + n // 2], u[-1 + n // 2]]:
for Y in [t[0], u[0], t[-1], u[-1], t[n // 2], u[n // 2], t[-1 + n // 2], u[-1 + n // 2]]:
tmp = abs(X[0] - Y[0]) + abs(X[1] - Y[1])
res = max(res, tmp)
print(res)
|
p02556
|
s573234257
|
Wrong Answer
|
n=int(input())
ans=[]
for i in range(n):
x,y=map(int,input().split())
ans.append(x+y)
ans=sorted(ans)
print(ans[-1]-ans[0])
|
p02556
|
s571652112
|
Wrong Answer
|
n = int(input())
xy = [map(int, input().split()) for _ in range(n)]
x, y = [list(i) for i in zip(*xy)]
result = []
for i in range(n - 1):
for j in range(n - 1):
result.append(abs(x[i] - x[j]) + abs(y[i] - y[j]))
print(max(result))
|
p02556
|
s792577020
|
Wrong Answer
|
n = int(input())
xy = [list(map(int,input().split()))for _ in range(n)]
xsort = sorted(xy,key=lambda x:x[0])
ysort = sorted(xy,key=lambda x:x[1])
ans = 0
for i in range(min(n,10**3)):
for j in range(min(n,10**3)):
ans = max(ans,abs(xsort[i][0]-xsort[-j][0])+abs(xsort[i][1]-xsort[-j][1]))
ans = max(ans,abs(ysort[i][0]-ysort[-j][0])+abs(ysort[i][1]-ysort[-j][1]))
print(ans)
|
p02556
|
s575035424
|
Wrong Answer
|
from sys import stdin
nii=lambda:map(int,stdin.readline().split())
lnii=lambda:tuple(map(int,stdin.readline().split()))
n=int(input())
l=set(tuple([lnii() for i in range(n)]))
if len(l)==1:
print(0)
exit()
x_max=0
x_min=10**10
y_max=0
y_min=10**10
ans=0
for x,y in l:
# s=abs(x-y)
s=x-y
x_max=max(x_max,s)
x_min=min(x_min,s)
# t=abs(x+y)
t=x+y
y_max=max(y_max,t)
y_mim=min(y_min,t)
ans=max(s,y)
print(ans)
|
p02556
|
s964685139
|
Wrong Answer
|
n = int(input())
X = []
Y = []
for i in range(n):
x, y = map(int, input().split())
X.append(x)
Y.append(y)
maxXidx = X.index(max(X))
maxYidx = Y.index(max(Y))
minXidx = X.index(min(X))
minYidx = Y.index(min(Y))
ans = max(abs(X[maxXidx] - X[minXidx]) + abs(Y[maxXidx] - Y[minXidx]),abs(X[maxYidx] - X[minYidx]) + abs(Y[maxYidx] - Y[minYidx]))
print(ans)
|
p02556
|
s389222791
|
Wrong Answer
|
import sys
input = sys.stdin.readline
n = int(input())
xy = tuple(map(int, input().split()))
pM = sum(xy)
pm = sum(xy)
mM = abs(xy[1] - xy[0])
mm = abs(xy[1] - xy[0])
for _ in range(n - 1):
xy = tuple(map(int, input().split()))
s = sum(xy)
d = abs(xy[0] - xy[1])
if s > pM:
pM = s
elif s < pm:
pm = s
if d > mM:
mM = d
elif d < mm:
mm = d
print(max(abs(pM-pm), abs(mM-mm)))
|
p02556
|
s992869119
|
Wrong Answer
|
N = int(input())
XY = [list(map(int, input().split())) for _ in range(N)]
x0 = 10 ** 9
y0 = 10 ** 9
d = x0 + y0
M = 0
m = 2 * d + 1
for x, y in XY:
p = x + y + d
if p > M:
M = p
elif p < m:
m = p
# print(M, m)
print(M - m)
|
p02556
|
s712426146
|
Wrong Answer
|
#!/usr/bin/env python3
import sys
from collections import deque, Counter
from heapq import heappop, heappush
from bisect import bisect_right
from itertools import accumulate
sys.setrecursionlimit(10**6)
INF = 10**12
m = 10**9 + 7
N = int(input())
x = [None] * N
y = [None] * N
for i in range(N):
x[i], y[i] = map(int, input().split())
xmax = x.index(max(x))
xmin = x.index(min(x))
ymax = y.index(max(y))
ymin = y.index(min(y))
ans = 0
for i in [xmin, ymin]:
for j in [xmax, ymax]:
ans = max(ans, abs(x[i]-x[j])+abs(y[i]-y[j]))
print(ans)
|
p02556
|
s352147304
|
Wrong Answer
|
import sys
input = sys.stdin.readline
N = int(input())
mn = 10 ** 10
mx = -10 ** 10
for _ in range(N):
x, y = map(int, input().split())
mn = min(mn, x + y)
mx = max(mx, x + y)
print(abs(mx - mn))
|
p02556
|
s854817922
|
Wrong Answer
|
N = int(input())
z = []
for _ in range(N):
x, y = list(map(int, input().split()))
z.append([x, y])
z.sort()
mdct = 0
lx, ly = z[0]
for x, y in z:
mdct = max(mdct, abs(x-lx) + abs(y-ly))
z.sort(key=lambda k: k[1])
lx, ly = z[0]
for x, y in z:
mdct = max(mdct, abs(x-lx) + abs(y-ly))
print(mdct)
|
p02556
|
s723568910
|
Wrong Answer
|
#
import sys
input=sys.stdin.readline
def main():
N = int(input())
R = [tuple(map(int, input().split())) for i in range(N)]
A = sorted(R, key = lambda x: x[0] + x[1])
print(abs(A[-1][0] - A[0][0]) + abs(A[-1][1] - A[0][1]))
if __name__=="__main__":
main()
|
p02556
|
s725418175
|
Wrong Answer
|
n = int(input())
lst1 = [0]*n
lst2 = [0]*n
M1 = M2 = 0
m1 = m2 = float('inf')
for i in range(n):
x, y = map(int, input().split())
d1 = x+y
d2 = x-y
M1 = max(M1, d1)
m1 = min(m1, d1)
M2 = max(M2, d2)
m2 = min(m2, d2)
d1 = M1-m1
d2 = M2-m2
print(max(d1, d2))
|
p02556
|
s456470288
|
Wrong Answer
|
N = int(input())
a_max = 2
a_min = 2*(10**9)
s_max = 0
s_min = 10**9-1
for i in range(N):
x,y=map(int,input().split())
add = x+y
sub = x-y
if add > a_max:
a_max = add
if add < a_min:
a_min = add
if sub > s_max:
s_max = sub
if sub < s_max:
s_max = sub
d_add = a_max - a_min
d_sub = s_max - s_min
print(max(d_add,d_sub))
|
p02556
|
s693474057
|
Wrong Answer
|
N=int(input())
P=[list(map(int,input().split())) for _ in range(N)]
L1=[]
L2=[]
L3=[]
L4=[]
for x,y in P:
L1.append(x+y)
L2.append(-x+y)
L3.append(x-y)
L4.append(-x-y)
L1=sorted(L1)
L2=sorted(L1)
L3=sorted(L1)
L4=sorted(L1)
ans=max(L1[-1]-L1[0],L2[-1]-L2[0],L3[-1]-L3[0],L4[-1]-L4[0])
print(ans)
|
p02556
|
s115535284
|
Wrong Answer
|
N = int(input())
x = [0] * N
y = [0] * N
for i in range(N):
x[i], y[i] = map(int, input().split())
for i in range(N):
x[i] = x[i] - y[i]
y[i] = x[i] + y[i]
print(max(max(x),max(y))-min(min(x),min(y))-1)
|
p02556
|
s632662107
|
Wrong Answer
|
rt = 0
N = int(input())
nums=[]
for _ in range(N):
nums.append(list(map(int,input().split())))
mn = nums[0][0] + nums[0][1]
mx = nums[0][0] + nums[0][1]
for i in nums:
mn = min(mn,i[0]+i[1])
mx = max(mx,i[0]+i[1])
print(mx-mn)
|
p02556
|
s903260248
|
Wrong Answer
|
n = int(input())
xy = []
for _ in range(n):
x,y = map(int,input().split())
xy.append((x,y))
al,be = 1000000000,1000000000
f = [(1,1),(1,-1),(-1,1),(-1,-1)]
ans = 1145141919810364
for k,l in f:
alfa = al * k
beta = be * l
man = []
for i,j in xy:
man.append((alfa-i) + (beta-j))
ans = min(ans,max(man) - min(man))
print(ans)
|
p02556
|
s351458867
|
Wrong Answer
|
from sys import stdin
nii=lambda:map(int,stdin.readline().split())
lnii=lambda:tuple(map(int,stdin.readline().split()))
n=int(input())
l=set(tuple([lnii() for i in range(n)]))
x_max=0
x_min=10**10
y_max=0
y_min=10**10
for x,y in l:
# s=abs(x-y)
s=x-y
x_max=max(x_max,s)
x_min=min(x_min,s)
# t=abs(x+y)
t=x+y
y_max=max(y_max,t)
y_min=min(y_min,t)
x_ans=x_max-x_min
y_ans=y_max-y_min
print(max(x_ans,y_ans))
|
p02556
|
s906330208
|
Wrong Answer
|
N = int(input())
p = [list(map(int, input().split())) for _ in range(N)]
a = []
for i, pos in enumerate(p):
a.append((sum(pos), i))
a.sort(key=lambda x:x[0])
ans = 0
for i in range(min(1000, N)):
for j in range(min(1000, N)):
xi, yi = p[a[i][1]]
xj, yj = p[a[N - j -1][1]]
ans = max(ans, abs(xi - xj) + abs(yi - yj))
print(ans)
|
p02556
|
s609791092
|
Wrong Answer
|
n = int(input())
a = []
for _ in range(n):
x, y = map(int, input().split())
a.append([x,y])
a.sort()
print(abs(a[0][0]-a[n-1][0])+abs(a[0][1]-a[n-1][1]))
|
p02556
|
s548343805
|
Wrong Answer
|
n=int(input())
l=[]
for _ in range(n):
l.append(tuple(map(int,input().split())))
ans=0
for i in range(n-1):
for j in range(i+1,n):
can=abs(l[i][0]-l[j][0])+abs(l[i][1]-l[j][0])
ans=max(ans,can)
print(ans)
|
p02556
|
s797243785
|
Wrong Answer
|
pnt=[]
n=int(input())
for i in range(n):
pnt.append(list(map(int,input().split())))
z=[]
w=[]
for i in pnt:
z.append(i[0]+i[1])
w.append(i[0]+i[1])
print(max(max(z)-min(z),max(w)-min(w)))
|
p02556
|
s611827560
|
Wrong Answer
|
N = int(input())
X = []
Y = []
for _ in range(N):
x,y = map(int,input().split())
X.append(x)
Y.append(y)
sumxy = [x+y for x,y in zip(X,Y)]
sumxy = sorted(sumxy,reverse = False)
ans = sumxy[-1] - sumxy[0]
print(ans)
|
p02556
|
s651703621
|
Wrong Answer
|
n = int(input())
p = []
for i in range(n):
x, y = map(int, input().split())
p.append([x, y])
p.sort(key=lambda x: (x[0]**2 + x[1]**2))
a = []
for i in range(min(n, 1000)):
for j in range(min(n, 1000)):
a.append(abs(p[-(i+1)][0] - p[j][0]) + abs(p[-(i+1)][1] - p[j][1]))
print(max(a))
|
p02556
|
s287551341
|
Wrong Answer
|
N=int(input())
A=[list(map(int, input().split())) for _ in range(N)]
B=[]
for i,j in A:
B.append(i+j)
print(max(B)-min(B))
|
p02556
|
s114945156
|
Wrong Answer
|
#import random
n=int(input())
pnt=[]
for i in range(n):
pnt.append(list(map(int,input().split())))
#pnt.append([random.randint(int(-1e9),int(1e9)),random.randint(int(-1e9),int(1e9))])
pnt.sort(key=lambda x:abs(x[0])+abs(x[1]),reverse=True)
mn=list(reversed(pnt))
mx=0
for i in range(min(n,5000)):
for j in range(i+1,min(n,5000)):
mx=max(abs(pnt[i][0]-pnt[j][0])+abs(pnt[i][1]-pnt[j][1]),mx)
mx=max(abs(pnt[i][0]-mn[j][0])+abs(pnt[i][1]-mn[j][1]),mx)
print(mx)
|
p02556
|
s388306281
|
Wrong Answer
|
n = int(input())
p = [list(map(int, input().split())) for _ in range(n)]
q = [[x+y, x-y] for x, y in p]
print(max(max(q)[0] - min(q)[0], max(q, key=lambda x: x[1])[0] - min(q, key=lambda x: x[1])[0]))
|
p02556
|
s163455917
|
Wrong Answer
|
#!python3
import sys
iim = lambda: map(int, sys.stdin.readline().rstrip().split())
from operator import sub
def resolve():
it = map(int, sys.stdin.read().split())
N = next(it)
M = 10**9+1
data = [[M, 0], [M, 0]]
for x, y in zip(it, it):
for i, x in enumerate([x+y, x-y]):
for j, f in enumerate([min, max]):
data[i][j] = f(data[i][j], x)
print(max(map(lambda x: abs(sub(*x)), data)))
if __name__ == "__main__":
resolve()
|
p02556
|
s370782525
|
Wrong Answer
|
from math import inf
from operator import itemgetter
N=int(input())
points=[]
for _ in range(N):
a,b=map(int,input().split( ))
points.append([a,b])
points.sort(key=itemgetter(0))
m1=-inf
m2=inf
m3=-inf
m4=inf
for x,y in points:
m1=max(m1,x+y)
m2=min(m2,x+y)
m3=max(m3,abs(x-y))
m4=min(m4,abs(x-y))
print(max(m1-m2,m3-m4))
|
p02556
|
s722480494
|
Wrong Answer
|
n = int(input())
xy = [list(map(int, input().split())) for i in range(n)]
p = [abs(a[0])+abs(a[1]) for a in xy]
px = max(p)
pn = min(p)
ans =px-pn
print(ans)
|
p02556
|
s831665184
|
Wrong Answer
|
N = int(input())
XY = [list(map(int, input().split())) for _ in range(N)]
min_diff = 10**9
max_diff = 1
min_sum = 2 * 10**9
max_sum = 2
for x,y in XY:
min_diff = min(abs(x-y), min_diff)
max_diff = max(abs(x-y), max_diff)
min_sum = min(x+y, min_sum)
max_sum = max(x+y, max_sum)
print(max(max_sum-min_sum, max_diff-min_diff))
|
p02556
|
s729295037
|
Wrong Answer
|
n = int(input())
xy = [[int(i) for i in input().split()] for j in range(n)]
mi = 10**9
ma = 0
for i in range(n):
tmp = xy[i][0] + xy[i][1]
if tmp > ma:
ma = tmp
#print(tmp,mi)
if tmp < mi:
mi = tmp
print(ma-mi)
#print(ma,mi)
|
p02556
|
s521651957
|
Wrong Answer
|
N = int(input())
x = [0]*N
y = [0]*N
for i in range(N):
x[i], y[i] = map(int, input().split())
m1 = 0
mp1 = 0
for i in range(N):
d = abs(x[i]-x[0])+abs(y[i]-y[0])
if d>m1:
m1 = d
mp1 = i
m2 = 0
mp2 = 0
for i in range(N):
d = abs(x[i]-x[mp1])+abs(y[i]-y[mp1])
if d>m2:
m2 = d
mp2 = i
ans = 0
for i in range(N):
ans = max(ans, abs(x[i]-x[mp2])+abs(y[i]-y[mp2]))
print(ans)
|
p02556
|
s454026012
|
Wrong Answer
|
n = int(input())
x = [0 for _ in range(n)]
for i in range(n):
x[i] = list(map(int, input().split()))
x[i].append(x[i][0]**2 + x[i][1]**2)
x.sort(key = lambda s:s[2])
ans = 0
for i in x:
ans = max(ans, abs(x[-1][0] - i[0]) + abs(x[-1][1] - i[1]))
print(ans)
|
p02556
|
s473011698
|
Wrong Answer
|
N = int(input())
ma = 0
mi = 10**18
xy = [list(map(int,input().split())) for _ in range(N)]
#print(xy)
for i in range(N):
ma=max(ma,xy[i][0]+xy[i][1])
mi=min(mi,xy[i][0]+xy[i][1])
print(ma-mi)
|
p02556
|
s257160625
|
Wrong Answer
|
N = int(input())
dists = []
while N:
x, y = map(int, input().split())
dists.append((x, y, x+y))
N -= 1
dists.sort(key=lambda x: x[2])
print(abs(dists[0][0] - dists[-1][0] + dists[0][1] - dists[-1][1]))
|
p02556
|
s842967687
|
Wrong Answer
|
# Fast IO (be careful about bytestring, not on interactive)
import os,io
input=io.BytesIO(os.read(0,os.fstat(0).st_size)).readline
N = int(input())
sumList = []
subList = []
for _ in range(N):
x,y = map(int,input().split())
sumList.append(x + y)
subList.append(x - y)
print(max(max(sumList),max(subList)))
|
p02556
|
s348410826
|
Wrong Answer
|
N = int(input())
XY = [list(map(int, input().split())) for _ in range(N)]
min_diff = 10**9
max_diff = 0
min_sum = 2 * 10**9
max_sum = 2
for x,y in XY:
min_diff = min(x-y, min_diff)
max_diff = max(x-y, max_diff)
min_sum = min(x+y, min_sum)
max_sum = max(x+y, max_sum)
print(max(max_sum-min_sum, max_diff-min_diff))
|
p02556
|
s943633052
|
Wrong Answer
|
n = int(input())
xy = [list(map(int, input().split())) for _ in range(n)]
yx = [[y, x] for x, y in xy]
xy.sort()
yx.sort()
yx = [[x, y] for y, x in yx]
ans = 0
tmp = [xy[0], xy[-1], yx[0], yx[-1]]
for x, y in tmp:
for x1, y1 in tmp:
ans = max(ans, abs(x - x1) + abs(y - y1))
print(ans)
|
p02556
|
s077892067
|
Wrong Answer
|
import sys
sys.setrecursionlimit(10 ** 7)
input = sys.stdin.readline
f_inf = float('inf')
mod = 10 ** 9 + 7
def resolve():
n = int(input())
XY = [list(map(int, input().split())) for _ in range(n)]
dist = []
for i in range(n):
x, y = XY[i]
dist.append([x + y, XY[i]])
dist.sort()
res = dist[-1][1][0] - dist[0][1][0] + dist[-1][1][1] - dist[0][1][1]
print(res)
if __name__ == '__main__':
resolve()
|
p02556
|
s921172875
|
Wrong Answer
|
n=int(input())
X=[]
Y=[]
for i in range(n):
x,y=map(int,input().split())
X.append(x)
Y.append(y)
fX=[]
fY=[]
for i in range(n):
fX.append(X[i]+Y[i])
fY.append(X[i]-Y[i])
xmax=0
xmin=2**62
ymax=0
ymin=2**62
for i in range(n):
xmax=max(xmax,fX[i])
xmin=min(xmin,fX[i])
ymax=max(ymax,fY[i])
ymin=min(ymin,fY[i])
print(max(xmax-xmin,ymax-ymin))
|
p02556
|
s287766396
|
Wrong Answer
|
n = int(input())
maxx = 0
minn = 2000000001
for i in range(n):
x,y = map(int,input().split())
minn = min(minn,x+y)
maxx = max(maxx,x+y)
print(maxx-minn)
|
p02556
|
s296499431
|
Wrong Answer
|
N = int(input())
K = []
for i in range(N):
x, y = map(int,input().split())
t = x + y
if x <= 0:
t -= 4*abs(x)
if y <= 0:
t -= 4*abs(y)
K.append([t, x, y])
K.sort()
ans = abs(K[0][0] - K[-1][0])
A = [K[0][1]]
for i in range(N-1):
if K[i][0] == K[i+1][0]:
A.append(K[i+1][1])
else:
ans = max(ans, max(A) - min(A))
A = [K[i][1]]
print(ans)
|
p02556
|
s242145986
|
Wrong Answer
|
n=int(input())
s,p=10**10,10**10
t,q=-1,-1
for i in range(n):
x,y=map(int,input().split())
s=min(s,x+y)
t=max(t,x+y)
p=min(p,x-y)
q=max(q,x-y)
print(max(t-s,q-p))
|
p02556
|
s765404759
|
Wrong Answer
|
n = int(input())
xy = []
for _ in range(n):
x,y = map(int,input().split())
xy.append((x,y))
al,be = 1000000000,1000000000
man = []
for i,j in xy:
man.append((al-i) + (be-j))
print(max(man) - min(man))
|
p02556
|
s600176033
|
Wrong Answer
|
n = int(input())
inf = float('inf')
M1, M2 = 0, 0
m1, m2 = inf, inf
for i in range(n):
x, y = map(int, input().split())
d1 = x+y
d2 = x-y
M1 = max(M1, d1)
m1 = min(m1, d1)
M2 = max(M2, d2)
m2 = min(m2, d2)
D1 = M1-m1
D2 = M2-m2
print(max(D1, D2))
|
p02556
|
s283054210
|
Wrong Answer
|
n=int(input())
l=set()
for _ in range(n):
x,y=map(int,input().split())
l.add(x+y)
l=list(l)
print(l[len(l)-1]-l[0])
|
p02556
|
s242116795
|
Wrong Answer
|
import math
n=int(input())
a,b=0,0
c,v,b,m=0,0,0,0
for i in range(n):
x,y=map(int,input().split())
c=max(x+y,c)
if i==0:
v=x+y
else:
v=min(x+y,v)
if math.fabs(x-y)>b:
m=b
b=max(b,math.fabs(x-y))
print(int(max(c-v, m+b)))
|
p02556
|
s163426460
|
Wrong Answer
|
import itertools
n = int(input())
ps = [
tuple(map(int, input().split()))
for _ in range(n)
]
xg = sum([p[0] for p in ps]) / len(ps)
yg = sum([p[1] for p in ps]) / len(ps)
maxd = 0
maxp = ps[0]
for p in ps:
d = abs(xg - p[0]) + abs(yg - p[1])
if d > maxd:
maxp = p
maxd = d
maxd = 0
for p in ps:
maxd = max(maxd, abs(maxp[0] - p[0]) + abs(maxp[1] - p[1]))
print(maxd)
|
p02556
|
s752097078
|
Wrong Answer
|
N = int(input())
xy = [list(map(int,input().split())) for _ in range(N)]
ma = 0
mi = float('inf')
for x,y in xy:
ma = max(ma,x-y)
mi = min(mi,x-y)
ans = ma - mi
print(ans)
|
p02556
|
s258902102
|
Wrong Answer
|
N = int(input())
z = [0]*N
for n in range(N):
x,y = map(int, input().split())
z[n] = abs(x) + abs(y)
print(max(z)-min(z))
|
p02556
|
s119137886
|
Wrong Answer
|
N = int(input())
xy = [list(map(int, input().split())) for _ in range(N)]
dist = [None] * N
for i in range(N):
dist[i] = abs(xy[i][0] - xy[0][0]) + abs(xy[i][1] - xy[0][1])
for j in range(50):
s = dist.index(max(dist))
for i in range(N):
dist[i] = abs(xy[i][0] - xy[s][0]) + abs(xy[i][1] - xy[s][1])
print(max(dist))
|
p02556
|
s320849297
|
Wrong Answer
|
N = int(input())
max_li = [0]*N
min_li = [0]*N
for i in range(N):
x,y = map(int, input().split())
if x-y >= 0:
arr = [x+y,x-y]
else:
arr = [x+y,y-x]
max_li[i] = max( arr )
min_li[i] = min( arr )
print( max(max_li)-min(min_li) -2 )
|
p02556
|
s743772911
|
Wrong Answer
|
n = int(input())
max1 = 0
min1 = 10 ** 10
max0 = 0
min0 = 10 ** 10
for i in range(n):
x,y = list(map(int,input().split()))
k0 = x - y
k1 = x + y
if k0 > max0:
max0 = k0
if k0 < min0:
min0 = k0
if k1 > max1:
max1 = k1
if k1 < min1:
min1 = k1
ans = int(max(max1-min1,max0-min0))
print(ans)
|
p02556
|
s357149742
|
Wrong Answer
|
N=int(input())
xy=[tuple(map(int,input().split())) for _ in range(N)]
t=[]
for x,y in xy:
t.append((x*y,x,y))
t=sorted(t)
xy1=t[0]
xy2=t[-1]
ans=abs(xy1[1]-xy2[1])+abs(xy1[2]-xy2[2])
t=sorted(t,key=lambda x:x[1])
xy1=t[0]
xy2=t[-1]
ans=max(ans,abs(xy1[1]-xy2[1])+abs(xy1[2]-xy2[2]))
t=sorted(t,key=lambda x:x[2])
xy1=t[0]
xy2=t[-1]
ans=max(ans,abs(xy1[1]-xy2[1])+abs(xy1[2]-xy2[2]))
print(ans)
|
p02556
|
s126411222
|
Wrong Answer
|
n = int(input())
x = []
y = []
distance = []
for i in range(n):
x1, y1 = input().split()
x1 = int(x1)
y1 = int(y1)
x.append(x1)
y.append(y1)
for i in range(len(x)):
for j in range(len(x)):
temp = abs(x[i] - x[j]) + abs(y[i] - y[j])
distance.append(temp)
print(distance)
max = distance[0]
for i in range(1,len(distance)-1):
if distance[i] >= max:
max = distance[i]
print(max)
|
p02556
|
s212975139
|
Wrong Answer
|
N = int(input())
Array1 = []
Array2 = []
for i in range(N):
next_x, next_y = map(int, input().split())
s = next_x + next_y
t = next_x - next_y
Array1.append(s)
Array2.append(t)
print(max(max(Array1)-min(Array2),max(Array2)-min(Array1)))
|
p02556
|
s889533955
|
Wrong Answer
|
N = int(input())
X = []
for _ in range(N):
x, y = map(int, input().split())
X.append((x * 2, y * 2))
X = sorted(X, key = lambda x: -x[1])
x0, y0 = X[0]
ans = 0
for x, y in X[1:]:
ans = max(ans, y0 - y + abs(x - x0))
if abs(x0 - x) > y0 - y:
a = abs(x - x0) - (y - y0)
if x0 > x:
x0 += a
else:
x0 -= a
y0 += a
print(ans // 2)
|
p02556
|
s345401294
|
Wrong Answer
|
import random
N = int(input())
x = [0]*N
y = [0]*N
for i in range(N):
x[i], y[i] = map(int, input().split())
S = set()
for i in range(N):
S.add((x[i], y[i]))
S = list(S)
ans = 0
for i in range(6):
o = random.randint(0, len(S)-1)
m = 0
mp = 0
for i in range(N):
d = abs(x[i]-S[o][0])+abs(y[i]-S[o][1])
if d>m:
m = d
mp = i
for i in range(N):
ans = max(ans, abs(x[i]-x[mp])+abs(y[i]-y[mp]))
print(ans)
|
p02556
|
s143314501
|
Wrong Answer
|
n=int(input())
l=[]
max=0
for i in range(n):
k,kk=map(int, input().split())
m=l
while(len(m)>0):
h=m.pop()
ma=abs(h[0]-k)+abs(h[1]-kk)
if ma>max:
max=ma
l.append([k,kk])
print(max)
|
p02556
|
s712556951
|
Wrong Answer
|
import numpy as np
# import math
# import copy
# from collections import deque
import sys
input = sys.stdin.readline
# sys.setrecursionlimit(10000)
from scipy.spatial import distance
def main():
N = int(input())
xy = [list(map(int,input().split())) for i in range(N)]
xy = np.array(xy)
print(0)
main()
|
p02556
|
s341165408
|
Wrong Answer
|
n=int(input())
r=[list(map(int,input().split())) for _ in range(n)]
a,c,b,d=0,10**10,0,10**10
for i in range(n):
x,y=r[i]
a=max(a,abs(x+y))
c=min(c,abs(x+y))
b=max(b,abs(x-y))
d=min(d,abs(x-y))
print(max(a-c,b-d))
|
p02556
|
s033620057
|
Wrong Answer
|
n = int(input())
top1= 0
bot1= 10**10
top2= 0
bot2= 10**10
for _ in range(n):
x,y = map(int, input().split(' '))
tot1= x+y
tot2= x-y
if tot1> top1:
top1= tot1
if tot1< bot1:
bot1= tot1
if tot2>top2:
top2= tot2
if tot2<bot2:
bot2= tot2
print(max(top1-bot1, top2-bot2))
|
p02556
|
s399274173
|
Wrong Answer
|
import sys
read = sys.stdin.buffer.read
readline = sys.stdin.buffer.readline
readlines = sys.stdin.buffer.readlines
n = int(readline())
data = list(map(int,read().split()))
inf = 10**15
axis_p_max = -1 * inf
axis_p_min = inf
axis_m_max = -1 * inf
axis_m_min = inf
it = iter(data)
for x,y in zip(it,it):
axis_p_max = max(axis_p_max, x+y)
axis_p_min = min(axis_p_min, x+y)
axis_m_max = max(axis_m_max, x-y)
axis_m_min = min(axis_m_max, x-y)
ans = max(axis_p_max-axis_p_min, axis_m_max,axis_m_min)
print(ans)
|
p02556
|
s536894716
|
Wrong Answer
|
N = int(input())
i = []
j = []
for k in range(N):
x, y = map(int, input().split())
i.append(x+y)
j.append(-x-y)
print(max(abs(max(i)+max(j)), abs(min(i)+min(j))))
|
p02556
|
s333906933
|
Wrong Answer
|
#create date: 2020-09-13 22:30
import sys
stdin = sys.stdin
def ns(): return stdin.readline().rstrip()
def ni(): return int(ns())
def na(): return list(map(int, stdin.readline().split()))
def main():
n = ni()
amax = 0
amin = 10**20
for _ in range(n):
x, y = na()
amin = min(amin, x+y)
amax = max(amax, x+y)
print(amax-amin)
if __name__ == "__main__":
main()
|
p02556
|
s311639953
|
Wrong Answer
|
n = int(input())
ans = [0]*n
for i in range(n):
a,b = map(int,input().split())
ans[i] = a+b
print(abs(max(ans)-min(ans)))
|
p02556
|
s464455148
|
Wrong Answer
|
from itertools import combinations
charo=[list(map(int,input().split())) for i in range(int(input(())))]
wan=list(combinations(charo,2))
maximun=0
result=[abs(j[0][0]-j[1][0])+abs(j[0][1]-j[1][1]) for j in wan ]
print(max(result))
|
p02556
|
s973420997
|
Wrong Answer
|
n=int(input())
xy=[tuple(map(int, input().split())) for _ in range(n)]
fn=[lambda x:x[0]+x[1],lambda x:x[0]+x[1]]
ans=0
for f in fn:
xy.sort(key = f)
ans=max(ans,abs(f(xy[0])-f(xy[-1])))
print(ans)
|
p02556
|
s106544637
|
Wrong Answer
|
n = int(input())
maxPlus, minPlus, maxMinus, minMinus = 0, 10**9 , 0, 10**9
for _ in range(n):
x, y = map(int, input().split())
maxPlus = max(x + y, maxPlus)
minPlus = min(x + y, minPlus)
maxMinus = max(x - y, maxMinus)
minMinus = min(x - y, minMinus)
print(max(abs(maxPlus - minPlus), abs(maxMinus - minMinus)))
|
p02556
|
s598161060
|
Wrong Answer
|
N = int(input())
XY = [list(map(int,input().split())) for _ in range(N)]
for i in range(N):
XY[i][0], XY[i][1] = XY[i][0]-XY[i][1], XY[i][0]+XY[i][1]
ans = 0
for i in range(2):
tmp_1 = 0
tmp_2 = float("inf")
for j in range(N):
tmp_1 = max(tmp_1, XY[j][i])
tmp_2 = min(tmp_2, XY[j][i])
ans = max(ans, tmp_1-tmp_2)
print(ans)
|
p02556
|
s461835228
|
Wrong Answer
|
n = int(input())
zm = -2e10
zn = 30000000000
wm = -2e10
wn = 30000000000
while(n):
x,y = map(int,input().split())
zm = max(zm,x+y)
zn = min(zn,x+y)
wm = max(wm,x-y)
wn = min(wn,x-y)
n-=1
print(max(zm-zn,wm,wn))
|
p02556
|
s432574847
|
Wrong Answer
|
# author: Taichicchi
# created: 13.09.2020 21:51:21
import sys
def dist(p1, p2):
return abs(p1[0] - p2[0]) + abs(p1[1] - p2[1])
N = int(input())
ls = []
for i in range(N):
ls.append(list(map(int, input().split())))
ls.sort(key=lambda x: (x[0], x[1]))
ans = 0
for i in range(1, N):
ans = max(ans, dist(ls[0], ls[i]))
ls.sort(key=lambda x: (x[1], x[0]))
for i in range(1, N):
ans = max(ans, dist(ls[0], ls[i]))
print(ans)
|
p02556
|
s847896751
|
Wrong Answer
|
from sys import stdin
nii=lambda:map(int,stdin.readline().split())
lnii=lambda:list(map(int,stdin.readline().split()))
n=int(input())
l=[lnii() for i in range(n)]
if len(l)==1:
print(0)
exit()
x_max=0
x_min=10**10
y_max=0
y_min=10**10
for x,y in l:
s=x-y
x_max=max(x_max,s)
x_min=min(x_min,s)
t=x+y
y_max=max(y_max,t)
y_min=min(y_min,t)
x_ans=x_max-x_min
y_ans=y_max-y_min
print(max(x_ans,y_ans))
|
p02556
|
s584836916
|
Wrong Answer
|
import numpy as np
N = int(input())
max_z = 0
min_z = np.inf
max_w = 0
min_w = np.inf
for _ in range(N):
x, y = map(int, input().split())
z = x + y
w = x - y
max_z = max(max_z, z)
min_z = min(min_z, z)
max_w = max(max_w, w)
min_w = min(min_w, w)
print(max(max_z-min_z, max_w-min_w))
|
p02556
|
s259060949
|
Wrong Answer
|
n=int(input())
l=[]
max=0
for i in range(n):
k,kk=map(int, input().split())
m=list(l)
print(l)
while(len(m)>0):
h=m.pop()
ma=abs(h[0]-k)+abs(h[1]-kk)
if ma>max:
max=ma
l.append([k,kk])
print(max)
|
p02556
|
s725338343
|
Wrong Answer
|
n = int(input())
xy = [list(map(int, input().split())) for _ in range(n)]
num = 10*9 + 5
maxmax = 0
minmin = num
_min = num
_max = 0
for x, y in xy:
if x + y > maxmax:
maxmax = x + y
if x - y > _max:
_max = x - y
if x + y < minmin:
minmin = x + y
if y - x < _min:
_min = y - x
result = maxmax - minmin if maxmax - minmin > _max - _min else _max - _min
print(result)
|
p02556
|
s300300513
|
Wrong Answer
|
N = int(input())
i = []
j = []
for k in range(N):
x, y = map(int, input().split())
i.append(x+y)
j.append(-x-y)
p = max(i)
del j[i.index(max(i))]
m = max(j)
print(p+m)
|
p02556
|
s831912431
|
Wrong Answer
|
n=int(input())
ab=[list(map(int,input().split())) for _ in range(n)]
a = 0
b = 0
l = [0]*n
for i in range(n):
a += ab[i][0]
b += ab[i][1]
a = a/n
b = b/n
for j in range(n):
l[j] = abs(ab[j][0]-a) + abs(ab[j][1]-b)
c = l.index(max(l))
l[c] = 0
d = l.index(max(l))
e = abs(ab[c][0]-ab[d][0]) + abs(ab[c][1]-ab[d][1])
print(e)
|
p02556
|
s061196632
|
Wrong Answer
|
N = int(input())
def f0(x,y):
return x-y
def f1(x,y):
return x+y
max0 = 0
max1 = 0
min0 = 10**10
min1 = 10**10
for i in range(N):
x,y = map(int, input().split())
a = f0(x,y)
b = f1(x,y)
max0 = max(a, max0)
min0 = min(a, min0)
max1 = max(b, max1)
min1 = min(b, min1)
res = max(max0-min0, max1-min1)
if res < 0:
res = 0
print(res)
|
p02556
|
s187559686
|
Wrong Answer
|
N = int(input())
xy = [list(map(int, input().split())) for _ in range(N)]
sum_xy = sorted([x+y for x, y in xy])
print(sum_xy[-1] - sum_xy[0])
|
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.