Problem:


Score : 500 points

Problem Statement

There are N points on the 2D plane, i-th of which is located on (x_i, y_i).
There can be multiple points that share the same coordinate.
What is the maximum possible Manhattan distance between two distinct points?

Here, the Manhattan distance between two points (x_i, y_i) and (x_j, y_j) is defined by |x_i-x_j| + |y_i-y_j|.

Constraints

2 \leq N \leq 2 \times 10^5

1 \leq x_i,y_i \leq 10^9

All values in input are integers.

Input

Input is given from Standard Input in the following format:

N
x_1 y_1
x_2 y_2
:
x_N y_N

Output

Print the answer.

Sample Input 1

3
1 1
2 4
3 2

Sample Output 1

4

The Manhattan distance between the first point and the second point is |1-2|+|1-4|=4, which is maximum possible.

Sample Input 2

2
1 1
1 1

Sample Output 2

0



Sample input:
3
1 1
2 4
3 2


Sample output:
4

Submission status: Wrong Answer

Solution code:
# ---------------------------iye ha aam zindegi---------------------------------------------
import math
import random
import heapq, bisect
import sys
from collections import deque, defaultdict
from fractions import Fraction
import sys
import threading
from collections import defaultdict
#threading.stack_size(10**8)
mod = 10 ** 9 + 7
mod1 = 998244353

# ------------------------------warmup----------------------------
import os
import sys
from io import BytesIO, IOBase
#sys.setrecursionlimit(300000)

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")


# -------------------game starts now----------------------------------------------------import math
class TreeNode:
    def __init__(self, k, v):
        self.key = k
        self.value = v
        self.left = None
        self.right = None
        self.parent = None
        self.height = 1
        self.num_left = 1
        self.num_total = 1


class AvlTree:

    def __init__(self):
        self._tree = None

    def add(self, k, v):
        if not self._tree:
            self._tree = TreeNode(k, v)
            return
        node = self._add(k, v)
        if node:
            self._rebalance(node)

    def _add(self, k, v):
        node = self._tree
        while node:
            if k < node.key:
                if node.left:
                    node = node.left
                else:
                    node.left = TreeNode(k, v)
                    node.left.parent = node
                    return node.left
            elif node.key < k:
                if node.right:
                    node = node.right
                else:
                    node.right = TreeNode(k, v)
                    node.right.parent = node
                    return node.right
            else:
                node.value = v
                return

    @staticmethod
    def get_height(x):
        return x.height if x else 0

    @staticmethod
    def get_num_total(x):
        return x.num_total if x else 0

    def _rebalance(self, node):

        n = node
        while n:
            lh = self.get_height(n.left)
            rh = self.get_height(n.right)
            n.height = max(lh, rh) + 1
            balance_factor = lh - rh
            n.num_total = 1 + self.get_num_total(n.left) + self.get_num_total(n.right)
            n.num_left = 1 + self.get_num_total(n.left)

            if balance_factor > 1:
                if self.get_height(n.left.left) < self.get_height(n.left.right):
                    self._rotate_left(n.left)
                self._rotate_right(n)
            elif balance_factor < -1:
                if self.get_height(n.right.right) < self.get_height(n.right.left):
                    self._rotate_right(n.right)
                self._rotate_left(n)
            else:
                n = n.parent

    def _remove_one(self, node):
        """
        Side effect!!! Changes node. Node should have exactly one child
        """
        replacement = node.left or node.right
        if node.parent:
            if AvlTree._is_left(node):
                node.parent.left = replacement
            else:
                node.parent.right = replacement
            replacement.parent = node.parent
            node.parent = None
        else:
            self._tree = replacement
            replacement.parent = None
        node.left = None
        node.right = None
        node.parent = None
        self._rebalance(replacement)

    def _remove_leaf(self, node):
        if node.parent:
            if AvlTree._is_left(node):
                node.parent.left = None
            else:
                node.parent.right = None
            self._rebalance(node.parent)
        else:
            self._tree = None
        node.parent = None
        node.left = None
        node.right = None

    def remove(self, k):
        node = self._get_node(k)
        if not node:
            return
        if AvlTree._is_leaf(node):
            self._remove_leaf(node)
            return
        if node.left and node.right:
            nxt = AvlTree._get_next(node)
            node.key = nxt.key
            node.value = nxt.value
            if self._is_leaf(nxt):
                self._remove_leaf(nxt)
            else:
                self._remove_one(nxt)
            self._rebalance(node)
        else:
            self._remove_one(node)

    def get(self, k):
        node = self._get_node(k)
        return node.value if node else -1

    def _get_node(self, k):
        if not self._tree:
            return None
        node = self._tree
        while node:
            if k < node.key:
                node = node.left
            elif node.key < k:
                node = node.right
            else:
                return node
        return None

    def get_at(self, pos):
        x = pos + 1
        node = self._tree
        while node:
            if x < node.num_left:
                node = node.left
            elif node.num_left < x:
                x -= node.num_left
                node = node.right
            else:
                return (node.key, node.value)
        raise IndexError("Out of ranges")

    @staticmethod
    def _is_left(node):
        return node.parent.left and node.parent.left == node

    @staticmethod
    def _is_leaf(node):
        return node.left is None and node.right is None

    def _rotate_right(self, node):
        if not node.parent:
            self._tree = node.left
            node.left.parent = None
        elif AvlTree._is_left(node):
            node.parent.left = node.left
            node.left.parent = node.parent
        else:
            node.parent.right = node.left
            node.left.parent = node.parent
        bk = node.left.right
        node.left.right = node
        node.parent = node.left
        node.left = bk
        if bk:
            bk.parent = node
        node.height = max(self.get_height(node.left), self.get_height(node.right)) + 1
        node.num_total = 1 + self.get_num_total(node.left) + self.get_num_total(node.right)
        node.num_left = 1 + self.get_num_total(node.left)

    def _rotate_left(self, node):
        if not node.parent:
            self._tree = node.right
            node.right.parent = None
        elif AvlTree._is_left(node):
            node.parent.left = node.right
            node.right.parent = node.parent
        else:
            node.parent.right = node.right
            node.right.parent = node.parent
        bk = node.right.left
        node.right.left = node
        node.parent = node.right
        node.right = bk
        if bk:
            bk.parent = node
        node.height = max(self.get_height(node.left), self.get_height(node.right)) + 1
        node.num_total = 1 + self.get_num_total(node.left) + self.get_num_total(node.right)
        node.num_left = 1 + self.get_num_total(node.left)

    @staticmethod
    def _get_next(node):
        if not node.right:
            return node.parent
        n = node.right
        while n.left:
            n = n.left
        return n


# -----------------------------------------------binary seacrh tree---------------------------------------
class SegmentTree1:
    def __init__(self, data, default=0, func=lambda a, b: max(a , b)):
        """initialize the segment tree with data"""
        self._default = default
        self._func = func
        self._len = len(data)
        self._size = _size = 1 << (self._len - 1).bit_length()

        self.data = [default] * (2 * _size)
        self.data[_size:_size + self._len] = data
        for i in reversed(range(_size)):
            self.data[i] = func(self.data[i + i], self.data[i + i + 1])

    def __delitem__(self, idx):
        self[idx] = self._default

    def __getitem__(self, idx):
        return self.data[idx + self._size]

    def __setitem__(self, idx, value):
        idx += self._size
        self.data[idx] = value
        idx >>= 1
        while idx:
            self.data[idx] = self._func(self.data[2 * idx], self.data[2 * idx + 1])
            idx >>= 1

    def __len__(self):
        return self._len

    def query(self, start, stop):
        if start == stop:
            return self.__getitem__(start)
        stop += 1
        start += self._size
        stop += self._size

        res = self._default
        while start < stop:
            if start & 1:
                res = self._func(res, self.data[start])
                start += 1
            if stop & 1:
                stop -= 1
                res = self._func(res, self.data[stop])
            start >>= 1
            stop >>= 1
        return res

    def __repr__(self):
        return "SegmentTree({0})".format(self.data)


# -------------------game starts now----------------------------------------------------import math
class SegmentTree:
    def __init__(self, data, default=0, func=lambda a, b:a + b):
        """initialize the segment tree with data"""
        self._default = default
        self._func = func
        self._len = len(data)
        self._size = _size = 1 << (self._len - 1).bit_length()

        self.data = [default] * (2 * _size)
        self.data[_size:_size + self._len] = data
        for i in reversed(range(_size)):
            self.data[i] = func(self.data[i + i], self.data[i + i + 1])

    def __delitem__(self, idx):
        self[idx] = self._default

    def __getitem__(self, idx):
        return self.data[idx + self._size]

    def __setitem__(self, idx, value):
        idx += self._size
        self.data[idx] = value
        idx >>= 1
        while idx:
            self.data[idx] = self._func(self.data[2 * idx], self.data[2 * idx + 1])
            idx >>= 1

    def __len__(self):
        return self._len

    def query(self, start, stop):
        if start == stop:
            return self.__getitem__(start)
        stop += 1
        start += self._size
        stop += self._size

        res = self._default
        while start < stop:
            if start & 1:
                res = self._func(res, self.data[start])
                start += 1
            if stop & 1:
                stop -= 1
                res = self._func(res, self.data[stop])
            start >>= 1
            stop >>= 1
        return res

    def __repr__(self):
        return "SegmentTree({0})".format(self.data)


# -------------------------------iye ha chutiya zindegi-------------------------------------
class Factorial:
    def __init__(self, MOD):
        self.MOD = MOD
        self.factorials = [1, 1]
        self.invModulos = [0, 1]
        self.invFactorial_ = [1, 1]

    def calc(self, n):
        if n <= -1:
            print("Invalid argument to calculate n!")
            print("n must be non-negative value. But the argument was " + str(n))
            exit()
        if n < len(self.factorials):
            return self.factorials[n]
        nextArr = [0] * (n + 1 - len(self.factorials))
        initialI = len(self.factorials)
        prev = self.factorials[-1]
        m = self.MOD
        for i in range(initialI, n + 1):
            prev = nextArr[i - initialI] = prev * i % m
        self.factorials += nextArr
        return self.factorials[n]

    def inv(self, n):
        if n <= -1:
            print("Invalid argument to calculate n^(-1)")
            print("n must be non-negative value. But the argument was " + str(n))
            exit()
        p = self.MOD
        pi = n % p
        if pi < len(self.invModulos):
            return self.invModulos[pi]
        nextArr = [0] * (n + 1 - len(self.invModulos))
        initialI = len(self.invModulos)
        for i in range(initialI, min(p, n + 1)):
            next = -self.invModulos[p % i] * (p // i) % p
            self.invModulos.append(next)
        return self.invModulos[pi]

    def invFactorial(self, n):
        if n <= -1:
            print("Invalid argument to calculate (n^(-1))!")
            print("n must be non-negative value. But the argument was " + str(n))
            exit()
        if n < len(self.invFactorial_):
            return self.invFactorial_[n]
        self.inv(n)  # To make sure already calculated n^-1
        nextArr = [0] * (n + 1 - len(self.invFactorial_))
        initialI = len(self.invFactorial_)
        prev = self.invFactorial_[-1]
        p = self.MOD
        for i in range(initialI, n + 1):
            prev = nextArr[i - initialI] = (prev * self.invModulos[i % p]) % p
        self.invFactorial_ += nextArr
        return self.invFactorial_[n]


class Combination:
    def __init__(self, MOD):
        self.MOD = MOD
        self.factorial = Factorial(MOD)

    def ncr(self, n, k):
        if k < 0 or n < k:
            return 0
        k = min(k, n - k)
        f = self.factorial
        return f.calc(n) * f.invFactorial(max(n - k, k)) * f.invFactorial(min(k, n - k)) % self.MOD


# --------------------------------------iye ha combinations ka zindegi---------------------------------
def powm(a, n, m):
    if a == 1 or n == 0:
        return 1
    if n % 2 == 0:
        s = powm(a, n // 2, m)
        return s * s % m
    else:
        return a * powm(a, n - 1, m) % m


# --------------------------------------iye ha power ka zindegi---------------------------------
def sort_list(list1, list2):
    zipped_pairs = zip(list2, list1)

    z = [x for _, x in sorted(zipped_pairs)]

    return z


# --------------------------------------------------product----------------------------------------
def product(l):
    por = 1
    for i in range(len(l)):
        por *= l[i]
    return por


# --------------------------------------------------binary----------------------------------------
def binarySearchCount(arr, n, key):
    left = 0
    right = n - 1

    count = 0

    while (left <= right):
        mid = int((right + left) / 2)

        # Check if middle element is
        # less than or equal to key
        if (arr[mid] < key):
            count = mid + 1
            left = mid + 1

        # If key is smaller, ignore right half
        else:
            right = mid - 1

    return count


# --------------------------------------------------binary----------------------------------------
def countdig(n):
    c = 0
    while (n > 0):
        n //= 10
        c += 1
    return c
def binary(x, length):
    y = bin(x)[2:]
    return y if len(y) >= length else "0" * (length - len(y)) + y

def countGreater(arr, n, k):
    l = 0
    r = n - 1

    # Stores the index of the left most element
    # from the array which is greater than k
    leftGreater = n

    # Finds number of elements greater than k
    while (l <= r):
        m = int(l + (r - l) / 2)
        if (arr[m] >= k):
            leftGreater = m
            r = m - 1

        # If mid element is less than
        # or equal to k update l
        else:
            l = m + 1

    # Return the count of elements
    # greater than k
    return (n - leftGreater)


# --------------------------------------------------binary------------------------------------
n=int(input())
f=[]
for i in range(n):
    a,b=map(int,input().split())
    f.append(-a+b)
    f.append(a-b)
f.sort()
print(f[-1]-f[0])

Submission status: Wrong Answer

Solution code:
N = int(input())
XYs = [list(map(int, input().split())) for _ in range(N)]
XYs.sort()

prevX = None
minY = maxY = XYs[0][1]
ans = 0
for x, y in XYs:
    if prevX != x and prevX is not None:
        minY -= 1
        maxY += 1
    ans = max(ans, abs(minY-y), abs(maxY-y))
    minY = minY if minY < y else y
    maxY = maxY if maxY > y else y
    prevX = x
print(ans)

Submission status: Wrong Answer

Solution code:
n=int(input())
l=[list(map(int,input().split())) for _ in range(n)]
l.sort()
t=l[-1][0]-l[0][0]+l[-1][1]-l[0][1]
l.sort(key=lambda x: (x[1],x[0]))
# print(l)
t=max(t,l[-1][0]-l[0][0]+l[-1][1]-l[0][1])
print(t)

Submission status: Wrong Answer

Solution code:
n=int(input())
l=[]

for i in range(n):
  x,y=(map(int,input().split()))
  we=int(((x**2)+(y**2))**0.5)
  ll=[we,x,y]
  l.append(ll)

l.sort()
#print(l)
print((l[-1][2]-l[0][2])+(l[-1][1]-l[0][1]))

'''
  ll1=[ll[1],ll[0]]
  lan.append(ll1)

l.sort()
lan.sort()
we=abs(l[0][0]-l[-1][0])+abs(l[0][1]-l[-1][1])
we1=abs(lan[0][0]-lan[-1][0])+abs(lan[0][1]-lan[-1][1])
print(max(we,we1))
'''

Submission status: Wrong Answer

Solution code:
#!/usr/bin/env python3
import sys


def solve(N: int, x: "List[int]", y: "List[int]"):
    z = [xx+yy for xx, yy in zip(x, y)]
    return abs(min(z) - max(z))

# Generated by 1.1.7.1 https://github.com/kyuridenamida/atcoder-tools
def main():
    def iterate_tokens():
        for line in sys.stdin:
            for word in line.split():
                yield word
    tokens = iterate_tokens()
    N = int(next(tokens))  # type: int
    x = [int()] * (N)  # type: "List[int]"
    y = [int()] * (N)  # type: "List[int]"
    for i in range(N):
        x[i] = int(next(tokens))
        y[i] = int(next(tokens))
    print(solve(N, x, y))

def test():
    import doctest
    doctest.testmod()

if __name__ == '__main__':
    #test()
    main()

Submission status: Wrong Answer

Solution code:
import sys
def input(): return sys.stdin.readline().strip()
def mapint(): return map(int, input().split())
sys.setrecursionlimit(10**9)

N = int(input())

XY = []
for _ in range(N):
    x, y = mapint()
    XY.append((x, y))

sx, sy = XY[0]
tmp = -1
for nx, ny in XY[1:]:
    if abs(sx-nx)+abs(sy-ny)>tmp:
        tmp = abs(sx-nx)+abs(sy-ny)
        ex, ey = nx, ny

ans = -1
for nx, ny in XY:
    if abs(ex-nx)+abs(ey-ny)>ans:
        ans = abs(ex-nx)+abs(ey-ny)

print(ans)

Submission status: Wrong Answer

Solution code:
n=int(input())
M=[]
for i in range(n):
    x,y=map(int,input().split())
    M.append(x+y)
print(max(M)-min(M))

Submission status: Wrong Answer

Solution code:
# -*- coding: utf-8 -*-

N = int(input())

XY = []
for n in range(N):
    xy = (int(i) for i in input().split())
    XY.append(xy)

max_xy = 0
max_pos = (0, 0)
min_xy = 2 * 10**9
min_pos = (0, 0)
for (x, y) in XY:
    x_plus_y = x + y
    if x_plus_y > max_xy:
        max_xy = x_plus_y
        max_pos = (x, y)
    if x_plus_y < min_xy:
        min_xy = x_plus_y
        min_pos = (x, y)

# 右上と左下の点のマンハッタン距離を求める
(max_x, max_y) = max_pos
(min_x, min_y) = min_pos
man = abs(max_x - min_x) + abs(max_y - min_y)

print(man)

Submission status: Wrong Answer

Solution code:
from math import gcd

from math import factorial as f

from math import ceil, floor, sqrt
import math

import bisect
import re
import heapq

from copy import deepcopy
import itertools
from itertools import permutations

from sys import exit

ii = lambda: int(input())
mi = lambda: map(int, input().split())
li = lambda: list(map(int, input().split()))

yes = "Yes"
no = "No"


def main():
    f = [[0,0] for i in range(200005)]
    n = ii()
    for i in range(n):
        x,y = mi()
        f[i][0] = x+y
        f[i][1] = abs(x-y)
    xmax,ymax,xmin,ymin = 0,0,100000000000000000,10000000000000000
    for i in range(n):
        xmax = max(xmax,f[i][0])
        xmin = min(xmin,f[i][0])
        ymax = max(ymax,f[i][1])
        ymin = min(ymin,f[i][1])

    xmax = max(xmax-xmin,ymax-ymin)

    print(xmax)





main()

Submission status: Wrong Answer

Solution code:
x = input()

max = 1
min = 10**9
mem_max_x = 0
mem_max_y = 0
mem_min_x = 0
mem_min_y = 0

for _ in range(int(x)):
 a = input()
 ax = int(a.split()[0])
 ay = int(a.split()[1])
# l = (ax*ax + ay*ay)**0.5
 l = (ax*1 + ay*1)**1
# print(l)
 if l > max: 
  max = l
  mem_max_x = ax
  mem_max_y = ay
 if l < min:
  min = l
  mem_min_x = ax
  mem_min_y = ay
  
# a<x<b, c<y<d
# manhatan = max - min
#print("manha")
#print( max - min)
print( abs(mem_max_x - mem_min_x) +abs(mem_max_y - mem_min_y))

# bd, ac, ad, bc

Submission status: Wrong Answer

Solution code:
N = int(input())

p1 = tuple(map(int, input().split()))
p2 = tuple(map(int, input().split()))


if sum(p1) >= sum(p2):
  p_max, p_min = p1, p2
else:
  p_max, p_min = p2, p1


for _ in range(N-2):
  tmp = tuple(map(int, input().split()))
  if sum(tmp) > sum(p_max):
    p_max = tmp
  if sum(tmp) < sum(p_min):
    p_min = tmp

d = abs(p_max[0] - p_min[0]) + abs(p_max[1] - p_min[1])
  
print(d)

Submission status: Wrong Answer

Solution code:
N=int(input())

mmax=None
mmin=(0,0,0)
for i in range(N):
    x,y = map(int, input().split())
    if not mmax:
        mmax=(x,y,x+y)
        mmin=(x,y,x+y)
        continue
    if x+y > mmax[2]:
        mmax=(x,y,x+y)
    elif x+y < mmin[2]:
        mmin=(x,y,x+y)

print(mmax[2]-mmin[2])

Submission status: Wrong Answer

Solution code:
import sys
import random

input = lambda : sys.stdin.readline().rstrip()

n = int(input())
pairs = [map(int, input().split(" ")) for i in range(n)]

for i, (x, y) in enumerate(pairs):
    if i == 0:
        min_x = max_x = x
        min_y = max_y = y
        min_xi = [0]
        max_xi = [0]
        min_yi = [0]
        max_yi = [0]
    else:
        if x < min_x:
            min_xi = [i]
            min_x = x
        elif x == min_x:
            min_xi.append(i)

        if y < min_y:
            min_yi = [i]
            min_y = y
        elif y == min_y:
            min_yi.append(i)

        if x > max_x:
            max_xi = [i]
            max_x = x
        elif x == min_x:
            max_xi.append(i)

        if y > max_y:
            max_yi = [i]
            max_y = y
        elif y == min_y:
            max_yi.append(i)


max_iter = 100

fmax_dist = -2
max_dist = -1

final_out = 0

#print("min_xi", min_xi, "min_yi", min_yi, "max_xi", max_xi, "max_yi", max_yi)
randoms = [random.randint(0, n-1) for i in range(10)]
first_jibuns = set(min_xi + max_xi + min_yi + max_yi + randoms)

True
for first_jibun in first_jibuns:
    jibun = first_jibun
    #for iter_i in range(max_iter):
    while True:
        jx, jy = pairs[jibun]
        for cur_aite in range(n):
            if jibun == cur_aite:
                continue
            ax, ay = pairs[cur_aite]
            cdist = abs(jx-ax) + abs(jy-ay)
            
            if cdist > max_dist:
                next_jibun = cur_aite
                max_dist = cdist

        if fmax_dist == max_dist:
            out = max_dist
            break

        jibun = next_jibun 
        fmax_dist = max_dist
    final_out = max(final_out, out)
    
    
print(out)

Submission status: Wrong Answer

Solution code:
N = int(input())
x, y = map(int, input().split())
A = [[x, y] for i in range(8)]
for i in range(N - 1):
  x, y = map(int, input().split())
  if A[0][0] < x or (A[0][0] == x and A[0][1] < y):
    A[0][0] = x
    A[0][1] = y
  if A[1][1] < y or (A[1][1] == y and A[1][0] < x):
    A[1][0] = x
    A[1][1] = y
  if A[2][0] < x or (A[2][0] == x and A[2][1] > y):
    A[2][0] = x
    A[2][1] = y
  if A[3][1] > y or (A[3][1] == y and A[3][0] < x):
    A[3][0] = x
    A[3][1] = y
  if A[4][0] > x or (A[4][0] == x and A[4][1] > y):
    A[4][0] = x
    A[4][1] = y
  if A[5][1] > y or (A[5][1] == y and A[5][0] > x):
    A[5][0] = x
    A[5][1] = y
  if A[6][0] > x or (A[6][0] == x and A[6][1] < y):
    A[6][0] = x
    A[6][1] = y
  if A[7][1] < y or (A[7][1] == y and A[7][0] > x):
    A[7][0] = x
    A[7][1] = y
def distance(p, q):
  return(abs(p[0] - q[0]) + abs(p[1] - q[1]))
ans = 0
for i in [0, 1]:
  for j in [4, 5]:
    ans = max(ans, distance(A[i], A[j]))
for i in [2, 3]:
  for j in [6, 7]:
    ans = max(ans, distance(A[i], A[j]))
print(ans)

Submission status: Wrong Answer

Solution code:
from math import gcd

from math import factorial as f

from math import ceil, floor, sqrt
import math

import bisect
import re
import heapq

from copy import deepcopy
import itertools
from itertools import permutations

from sys import exit

ii = lambda: int(input())
mi = lambda: map(int, input().split())
li = lambda: list(map(int, input().split()))

yes = "Yes"
no = "No"


def main():
    f = [[0,0] for i in range(200005)]
    n = ii()
    for i in range(n):
        x,y = mi()
        f[i][0] = x+y
        f[i][1] = x-y
    xmax,ymax,xmin,ymin = 0,0,100000000000000000,10000000000000000
    for i in range(n):
        xmax = max(xmax,f[i][0])
        xmin = min(xmin,f[i][0])
        ymax = max(ymax,f[i][1])
        ymin = min(ymin,f[i][1])

    xmax = max(xmax-xmin,ymax-ymin)

    print(xmax)





main()

Submission status: Wrong Answer

Solution code:
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)

Submission status: Wrong Answer

Solution code:
import math

n = int(input())

x = list(range(n))
y = list(range(n))
m = list(range(n))
for i in range(n):
  x[i],y[i] = map(int,input().split())
  m[i] = x[i] + y[i]
m.sort()
res = abs(m[0]-m[n-1])
print(res)

Submission status: Wrong Answer

Solution code:
#: Author - Soumya Saurav
import sys,io,os,time
from collections import defaultdict
from collections import Counter
from collections import deque
from itertools import combinations
from itertools import permutations
import bisect,math,heapq
alphabet = "abcdefghijklmnopqrstuvwxyz"

input = sys.stdin.readline

########################################


n = int(input())
arr = set()
for i in range(n):
	x ,y = map(int , input().split())
	arr.add((x,y))
arr = sorted(arr , key = lambda x : (x[0],x[1]))
#print(arr)
#print(abs(arr[0][0] - arr[len(arr)-1][0]) + abs(arr[0][1] - arr[len(arr)-1][1]))
ans = float("-inf")
for i in range(1,len(arr)):
	#print("!!",abs(arr[0][0] - arr[i][0]) , abs(arr[0][1] - arr[i][1]))
	ans = max(ans , abs(arr[0][0] - arr[i][0]) + abs(arr[0][1] - arr[i][1]))
print(ans)






'''
# Wrap solution for more recursion depth
#submit as python3
import collections,sys,threading
sys.setrecursionlimit(10**9)
threading.stack_size(10**8)



threading.Thread(target=solve).start()
'''

Submission status: Wrong Answer

Solution code:
import sys

def input(): return sys.stdin.readline().strip()
def list2d(a, b, c): return [[c for j in range(b)] for i in range(a)]
def list3d(a, b, c, d): return [[[d for k in range(c)] for j in range(b)] for i in range(a)]
def list4d(a, b, c, d, e): return [[[[e for l in range(d)] for k in range(c)] for j in range(b)] for i in range(a)]
def ceil(x, y=1): return int(-(-x // y))
def INT(): return int(input())
def MAP(): return map(int, input().split())
def LIST(N=None): return list(MAP()) if N is None else [INT() for i in range(N)]
def Yes(): print('Yes')
def No(): print('No')
def YES(): print('YES')
def NO(): print('NO')
sys.setrecursionlimit(10**9)
INF = 10**19
MOD = 10**9 + 7
EPS = 10**-10

N = INT()
mnx = mny = INF
mxx = mxy = -INF
li = [()] * 4
XY = []
for i in range(N):
    x, y  = MAP()
    XY.append((x, y))
    if x < mnx:
        mnx = x
        li[0] = (x, y)
    if x > mxx:
        mxx = x
        li[1] = (x, y)
    if y < mny:
        mny = y
        li[2] = (x, y)
    if y > mxy:
        mxy = y
        li[3] = (x, y)

ans = 0
for i in range(4):
    if li[i]:
        sx, sy = li[i]
        for x, y in XY:
            ans = max(ans, abs(sx-x) + abs(sy-y))
print(ans)

Submission status: Wrong Answer

Solution code:
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)

   
    b=max(math.fabs(x-y),b)
    if i==0:
        m=math.fabs(x-y)
    else:
        m=min(math.fabs(x-y),m)
print(int(max(c-v, b-m)))

Submission status: Wrong Answer

Solution code:
import os
import sys
from atexit import register
from io import BytesIO
sys.stdin = BytesIO(os.read(0, os.fstat(0).st_size))
sys.stdout = BytesIO()
register(lambda: os.write(1, sys.stdout.getvalue()))
input = lambda: sys.stdin.readline().rstrip('\r\n')
raw_input = lambda: sys.stdin.readline().rstrip('\r\n')

n = int(input())
points = set()
for _ in xrange(n):
    x,y = (int(x) for x in input().split())
    points.add((x,y))

if len(points) <= 1:
    print(0)
else:
    srt1 = sorted(points, key=lambda x: x[0] + x[1])
    x1,y1 = srt1[0]
    x2,y2 = srt1[-1]
    ans1 = abs(x1+y1 - (x2+y2))
    srt2 = sorted(points, key=lambda x: x[0] - x[1])
    x1,y1 = srt2[0]
    x2,y2 = srt2[-1]
    ans2 = abs(x1+y1 - (x2+y2))
    print(max(ans1, ans2))

Submission status: Wrong Answer

Solution code:
n = int(input())

xy = []

for z in range(n):
    a = list(map(int,input().split()))
    xy.append(a)

def how_far(a,b):
    return abs(a[0]-b[0]) + abs(a[1]-b[1])

kyori = []

for i in range(n-1):
    s = how_far(xy[i],xy[i+1])
    kyori.append(s)

print(max(kyori))

Submission status: Wrong Answer

Solution code:
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)