Problem:


Score: 300 points

Problem Statement

In the Ancient Kingdom of Snuke, there was a pyramid to strengthen the authority of Takahashi, the president of AtCoder Inc.

The pyramid had center coordinates (C_X, C_Y) and height H. The altitude of coordinates (X, Y) is max(H - |X - C_X| - |Y - C_Y|, 0).  

Aoki, an explorer, conducted a survey to identify the center coordinates and height of this pyramid. As a result, he obtained the following information:  

C_X, C_Y was integers between 0 and 100 (inclusive), and H was an integer not less than 1.  

Additionally, he obtained N pieces of information. The i-th of them is: "the altitude of point (x_i, y_i) is h_i."  

This was enough to identify the center coordinates and the height of the pyramid. Find these values with the clues above.  

Constraints

N is an integer between 1 and 100 (inclusive).

x_i and y_i are integers between 0 and 100 (inclusive).

h_i is an integer between 0 and 10^9 (inclusive).

The N coordinates (x_1, y_1), (x_2, y_2), (x_3, y_3), ..., (x_N, y_N) are all different.

The center coordinates and the height of the pyramid can be uniquely identified.

Input

Input is given from Standard Input in the following format:  

N
x_1 y_1 h_1
x_2 y_2 h_2
x_3 y_3 h_3
:
x_N y_N h_N

Output

Print values C_X, C_Y and H representing the center coordinates and the height of the pyramid in one line, with spaces in between.  

Sample Input 1

4
2 3 5
2 1 5
1 2 5
3 2 5

Sample Output 1

2 2 6

In this case, the center coordinates and the height can be identified as (2, 2) and 6.  

Sample Input 2

2
0 0 100
1 1 98

Sample Output 2

0 0 100

In this case, the center coordinates and the height can be identified as (0, 0) and 100.

Note that C_X and C_Y are known to be integers between 0 and 100.

Sample Input 3

3
99 1 191
100 1 192
99 0 192

Sample Output 3

100 0 193

In this case, the center coordinates and the height can be identified as (100, 0) and 193.  



Sample input:
4
2 3 5
2 1 5
1 2 5
3 2 5


Sample output:
2 2 6

Submission status: Accepted

Solution code:
N = int(input())
xyh = [list(map(int,input().split())) for _ in range(N)]
xyh = sorted(xyh, key = lambda x: -x[2])
tx, ty, th = xyh[0]
for Cx in range(101):
  for Cy in range(101):
    H = th + abs(tx - Cx) + abs(ty - Cy)
    if(all(h == max(H - abs(x - Cx) - abs(y - Cy), 0) for x,y,h in xyh)):
      print(Cx, Cy, H)
      exit()

Submission status: Accepted

Solution code:
n = int(input())
li = []
for _ in range(n):
    x0, y0, h0 = list(map(int, input().split()))
    li.append((h0, x0, y0))

li.sort(reverse=True)
# all search
from itertools import product
for x, y in product(range(0, 101), repeat=2):
    h0, x0, y0 = li[0]
    h = h0 + abs(x0 - x) + abs(y0 - y)
    ok = True
    for h0, x0, y0 in li[1:]:
        if h0 != max(0, h - abs(x - x0) - abs(y - y0)):
            ok = False
            break
    if ok:
        break

print(x, y, h)

Submission status: Accepted

Solution code:
N = int(input())
L = []
M = []
for _ in range(N):
    l = list(map(int,input().split()))
    if l[2] != 0:
        L.append(l)
    else:
        M.append(l)

for i in range(101):
    for j in range(101):
        tmp = -1
        for x in L:
            H = abs(x[0]-i) + abs(x[1]-j) + x[2]
            if H < 1:
                break
            if tmp != -1 and tmp != H:
                break
            else:
                tmp = H
        else:
            for x in L:
                if x[2]==max(0,H-abs(x[0]-i)-abs(x[1]-j)):
                    pass
                else:
                    break
            else:
                for x in M:
                    if x[2]==max(0,H-abs(x[0]-i)-abs(x[1]-j)):
                        pass
                    else:
                        break
                else:
                    print(i,j,H)

Submission status: Accepted

Solution code:
# まじでわからんので解説読んだ
N = int(input())
xyh = []
for i in range(N):
    xyh.append(list(map(int, input().split())))
max_xyh = max(xyh, key=lambda x: x[2])  # hが一番大きいxyhの組み合わせを抽出
for Cx in range(101):
    for Cy in range(101):
        h = abs(max_xyh[0] - Cx) + abs(max_xyh[1] - Cy) + max_xyh[2]
        frag = True
        for ex_xyh in xyh:
            if max([h - abs(ex_xyh[0] - Cx) - abs(ex_xyh[1] - Cy), 0]) == ex_xyh[2]:
                continue
            else:
                frag = False
                break
        if frag:
            print(Cx, Cy, h)
            break

Submission status: Accepted

Solution code:
import sys

def is_center(x, y, P):
  H = [abs(x-p[0]) + abs(y-p[1]) + p[2] for p in P if p[2] != 0]
  return H


def center(C, P):
  for c in C:
    check = [p[2] == max(c[2] - abs(p[0] - c[0]) - abs(p[1] - c[1]), 0) for p in P]
    if all(check):
      return '{} {} {}'.format(c[0], c[1], c[2])

def main():
  input = sys.stdin.readline
  N = int(input())
  P = [[0, 0, 0] for _ in range(N)]

  for i in range(N):
    x, y, h = map(int, input().split())
    P[i][0], P[i][1], P[i][2] = x, y, h

  C = []
  for i in range(101):
    for j in range(101):
      H = is_center(i, j, P)
      if len(set(H)) == 1:
        C.append([i, j, H[0]])
  
  ans = center(C, P)
  print(ans)


if __name__ == '__main__':
  main()

Submission status: Accepted

Solution code:
class Solver(object):
    def __init__(self):
        self.n = int(input())
        self.heights = []
        for _ in range(self.n):
            self.heights.append(list(map(int, input().split(" "))))

    def solve(self):
        for cx in range(101):  # cx = 0 .. 100
            for cy in range(101):  # cy = 0 .. 100
                ch = 1
                for x, y ,h in self.heights:
                    if h > 0:
                        ch = h + abs(cx - x) + abs(cy - y)
                        break
                isValid = True
                for x, y, h in self.heights:
                    if max(ch - abs(cx - x) - abs(cy - y), 0) != h:
                        isValid = False
                if isValid:
                    print(cx, cy, ch)
                    return

    def debug(self):
        for h in self.heights:
            print(h)


if __name__ == "__main__":
    s = Solver()
    s.solve()

Submission status: Accepted

Solution code:
N = int(input())
xyh = [list(map(int,input().split())) for _ in range(N)]
xyh = sorted(xyh, key = lambda x: -x[2])
xt, yt, ht = xyh[0]
for Cx in range(101):
  for Cy in range(101):
    H = ht + abs(xt - Cx) + abs(yt - Cy)
    if(all(h == max(H - abs(x - Cx) - abs(y - Cy), 0) for x,y,h in xyh)):
      print(Cx, Cy, H)
      break
  else:
      continue
  break

Submission status: Accepted

Solution code:
n=int(input())
p=[[int(i)for i in input().split()] for _ in range(n)]
p.sort(key=lambda x: x[2])
a,b,c=p[-1]
for y in range(101):
    for x in range(101):
        h=c+abs(a-x)+abs(b-y)
        if all(k==max(h-abs(i-x)-abs(y-j),0) for i,j,k in p):
            print(x,y,h)
            exit()

Submission status: Accepted

Solution code:
def calc_height(xs, ys, hs, cx, cy):
    ret = -1
    zeros = []
    for i in range(len(xs)):
        x = xs[i]
        y = ys[i]
        h = hs[i]
        if h == 0:
            zeros.append((x,y,h))
            continue
        a = abs(x - cx)
        b = abs(y - cy)
        ch = h + a + b
        if ret == -1:
            ret = ch
        else:
            if ret != ch:
                return -1
    for x, y, h in zeros:
        a = abs(x - cx)
        b = abs(y - cy)
        if ret - a - b > 0:
            return -1
    return ret


def solve(xs, ys, hs):
    for cx in range(101):
        for cy in range(101):
            h = calc_height(xs, ys, hs, cx, cy)
            if h > 0:
                return cx, cy, h


n = int(input())
xs = []
ys = []
hs = []
for i in range(n):
    x, y, h = list(map(int, input().split(' ')))
    xs.append(x)
    ys.append(y)
    hs.append(h)


print(' '.join([str(q) for q in solve(xs, ys, hs)]))

Submission status: Accepted

Solution code:
N = int(input())
xyh = [(0,0,0)]*N
for i in range(N):
    x,y,h = map(int, input().split())
    xyh[i] = (x,y,h)
                 
for Cx in range(101):
    for Cy in range(101):
        for i in xyh:
            if i[2] != 0:
                H = i[2] + abs(i[1]-Cy) + abs(Cx- i[0])
                break
        for i in xyh:
            if i[2] != max(H-(abs(i[1]-Cy) + abs(Cx- i[0])), 0):
                break
        else:
            print(Cx,Cy,H)
            break

Submission status: Accepted

Solution code:
N = int(input())
x,y,h = [],[],[]
for i in range(N):
    a,b,c = map(int,input().split())
    x.append(a)
    y.append(b)
    h.append(c)

for cx in range(101):
    for cy in range(101):
        for i in range(N):
            H = abs(x[i] - cx) + abs(y[i] - cy) + h[i]
            if h[i] != 0:
                break
        for i in range(N):
            th = max( H - abs(x[i] - cx) - abs(y[i] - cy), 0 )
            if h[i] != th:
                break
        else:
            print(cx,cy,H)
            exit()

Submission status: Accepted

Solution code:
n = int(input())
p = []
for _ in range(n):
    p.append(list(map(int, input().split())))
p.sort(key = lambda x:x[2], reverse = True)
for i in range(101):
    for j in range(101):
        t = p[0][2] + abs(i - p[0][0]) + abs(j - p[0][1])
        if any([
            t != p[k][2] + abs(i - p[k][0]) + abs(j - p[k][1]) 
            if p[k][2] > 0 else t > abs(i - p[k][0]) + abs(j - p[k][1]) 
            for k in range(1, n)
        ]):
            continue
        else:
            print(i, j, t)
            break
    else:
        continue
    break

Submission status: Accepted

Solution code:
n = int(input())

arr = []

for i in range(n):
    x, y, h = map(int, input().split())
    arr.append([x, y, h])

for i in range(101):
    for j in range(101):
        for k in range(n):
            if arr[k][2] > 0:
                len1 = abs(arr[k][0] - i) + abs(arr[k][1] - j)
                ch = len1 + arr[k][2]
                break
            else:
                continue
        for k in range(n):
            lenk = abs(arr[k][0] - i) + abs(arr[k][1] - j)
            if max(ch - lenk, 0) == arr[k][2]:
                if k == n-1:
                    print("{} {} {}".format(i, j, ch))
                else:
                    continue
            else:
                break

Submission status: Accepted

Solution code:
n = int(input())
x = []
y = []
h = []
for i in range(n):
    xx, yy, hh = map(int, input().split())
    x.append(xx)
    y.append(yy)
    h.append(hh)
kk = h.index(max(h))
k = 0
for i in range(101):
    for j in range(101):
        ass = h[kk]+abs(x[kk]-i)+abs(y[kk]-j)
        for r in range(n):
            if h[r] == 0:
                if ass -abs(x[r]-i)-abs(y[r]-j) > 0:
                    ass = -1
            else:
                if ass != abs(x[r]-i)+abs(y[r]-j)+h[r]:
                    ass = -1
        if ass != -1:
                print(i, j, ass)
                break

Submission status: Accepted

Solution code:
# -*- coding: utf-8 -*-
# Luis Yoichi Morales January 2019


n = input()
arr = []
for i in range(n):
    xi, yi, hi = map(int, raw_input().split())
    arr.append((xi, yi, hi))

for cx in range(101):
    for cy in range(101):
        for k in range(n):
            if arr[k][2] > 0:
                H = abs(arr[k][0]-cx)+abs(arr[k][1]-cy) + arr[k][2]
                break
        flag = 0
        for k in range(n):
            if arr[k][2] != max(H - abs(arr[k][0]-cx) - abs(arr[k][1]-cy), 0):
                flag = 1
                break
        if flag == 0:
            print cx, cy, H

Submission status: Accepted

Solution code:
def main():
    n = int(input())
    xyhs = [list(map(int, input().split())) for _ in range(n)]
    for cy in range(0, 101):
        for cx in range(0, 101):
            x0, y0, h0 = next((x, y, h) for x, y, h in xyhs if h > 0)
            ch = h0 + abs(x0 - cx) + abs(y0 - cy)
            res = True
            for x, y, h in xyhs:
                hh = max(ch - abs(x - cx) - abs(y - cy), 0)
                if hh != h:
                    res = False
                    break
            if res:
                print(cx, cy, ch)
                return


if __name__ == "__main__":
    main()

Submission status: Accepted

Solution code:
N = int(input())
xyh = [list(map(int,input().split())) for _ in range(N)]
xyh = sorted(xyh, key = lambda x: -x[2])
xt, yt, ht = xyh[0]
for Cx in range(101):
  for Cy in range(101):
    H = ht + abs(xt - Cx) + abs(yt - Cy)
    if(all(h == max(H - abs(x - Cx) - abs(y - Cy), 0) for x,y,h in xyh)):
      print(Cx, Cy, H)
      exit()

Submission status: Accepted

Solution code:
n = int(input())
data = [tuple(map(int, input().split())) for _ in range(n)]
ax, ay, ah = list(filter(lambda x:x[2], data))[0]

for cx in range(101):
    for cy in range(101):
        H = ah + abs(ax-cx) + abs(ay-cy)
        if all(max(H-abs(d[0]-cx)-abs(d[1]-cy),0)==d[2] for d in data):
            print(cx, cy, H)
            exit()

Submission status: Accepted

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

for _ in range(n):
    x, y, h = map(int, input().split())
    data.append((x,y,h))

data.sort(key=lambda x:x[2], reverse=True)

for cx in range(101):
    for cy in range(101):
        flg = False
        # print(cx, cy)
        tmp = None
        for k in data:
            x = k[0]
            y = k[1]
            h = k[2]
            if not tmp:
                tmp = h+abs(cx-x)+abs(cy-y)
                continue
            if h == 0 and tmp>abs(cx-x)+abs(cy-y):
                flg = True
                break
            elif h == 0:
                continue
            elif tmp == h+abs(cx-x)+abs(cy-y):
                continue
            else:
                flg = True 
                break
        if flg:
            continue
        else:
            print(cx, cy, tmp)
            exit()

Submission status: Accepted

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

x,y,k=-1,-1,-1
t=-1
for o in range(n):
    a.append(list(map(int,input().split())))
    if a[o][2] != 0:
        t=o
for i in range(101):
    for j in range(101):
        h=a[t][2]+abs(a[t][0]-i)+abs(a[t][1]-j)
        d=True

        for l in range(n):
            if a[l][2] > 0 and h != a[l][2]+abs(a[l][0]-i)+abs(a[l][1]-j):
                d=False
            if a[l][2]==0 and h>abs(a[l][0]-i)+abs(a[l][1]-j):
                d=False
            
        if d:
            x,y,k=i,j,h
            print(x,y,k)
            exit()

Submission status: Accepted

Solution code:
n = int(input())
plist = [tuple(map(int, input().split())) for i in range(n)]
plist = sorted(plist, key = lambda x: -x[2])

for x in range(0,101):
    for y in range(0,101):
        h = -1
        for i in plist:
            diff = abs(i[0]-x) + abs(i[1]-y)
            if h == -1:
                h = diff + i[2]
            elif i[2] == 0:
                if h > diff:
                    break
            else:
                if h != diff + i[2]:
                    break
        else:
            if h <= 0:
                pass
            else:
                print("{} {} {}".format(x, y, h))

Submission status: Accepted

Solution code:

def solve(data):
    data = sorted(data, key=lambda x:-x[2])

    for cx in range(101):
        for cy in range(101):
            d0 = data[0]
            x,y,h = d0
            H = abs(x-cx)+abs(y-cy)+h
            flag = True
            for d in data[1:]:
                x,y,h = d
                if(max(H-abs(x-cx)-abs(y-cy),0) != h):
                    flag = False
                    break
            if(flag==True):
                return cx,cy,H

n = int(input())
data = [list(map(int,input().split())) for _ in range(n)]
# x, y, h

# print(data)
cx,cy,H = solve(data)
print(cx,cy,H)

Submission status: Accepted

Solution code:
n = int(input())
d = [list(map(int, input().split())) for i in range(n)]
for x in range(101):
  for y in range(101):
    for i in d:
      if i[2] > 0:
        H = i[2] + abs(x-i[0]) + abs(y-i[1])
        break
    if all(l[2] == max(H - abs(x-l[0]) - abs(y-l[1]), 0) for l in d):
      print('{} {} {}'.format(x, y, H))
      exit()

Submission status: Accepted

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

x,y,h=-1,-1,-1
nonzero=-1

for i in range(n):
    xyh.append(list(map(int,input().split())))
    if xyh[i][2] != 0:
        nonzero = i

for px in range(101):
    for py in range(101):
        nh = xyh[nonzero][2]+abs(xyh[nonzero][0]-px)+abs(xyh[nonzero][1]-py)
        ok = True

        for nn in range(n):
            if xyh[nn][2] > 0 and nh != xyh[nn][2]+abs(xyh[nn][0]-px) + abs(xyh[nn][1]-py):
                ok=False
            if xyh[nn][2] == 0 and nh > abs(xyh[nn][0]-px) +abs(xyh[nn][1]-py):
                ok=False
        
        if ok:
            x,y,h = px,py,nh
            print(x,y,h)
            exit()

Submission status: Accepted

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

ansx,ansy,ansh = -1,-1,-1
nonzero=-1

for i in range(n):
    xyh.append(list(map(int,input().split())))
    if xyh[i][2] != 0:      
        nonzero=i

for px in range(101):
    for py in range(101):
        nh = xyh[nonzero][2] + abs(xyh[nonzero][0]-px) + abs(xyh[nonzero][1]-py)
        ok = True

        for nn in range(n):
            if (xyh[nn][2] > 0 and nh != xyh[nn][2] + abs(xyh[nn][0]-px) + abs(xyh[nn][1]-py)): 
                ok=False
            if (xyh[nn][2] == 0 and nh >  abs(xyh[nn][0]-px) + abs(xyh[nn][1]-py)):
                ok=False
        if ok:
            ansx,ansy,ansh = px,py,nh
        
    
print(ansx,ansy,ansh)

Submission status: Accepted

Solution code:
N = int(input())
X_h = []
Y_h = []
H = []
X_0 = []
Y_0 = []
for i in range(N):
    x, y, h = map(int, input().split())
    if h == 0:
        X_0.append(x)
        Y_0.append(y)
    else:
        X_h.append(x)
        Y_h.append(y)
        H.append(h)


def solve(H, X_h, Y_h, X_0, Y_0):
    for C_x in range(101):
        for C_y in range(101):
            h = H[0] + abs(X_h[0] - C_x) + abs(Y_h[0] - C_y)
            flag = True
            for i in range(1, len(X_h)):
                if h != H[i] + abs(X_h[i] - C_x) + abs(Y_h[i] - C_y):
                    flag = False
                    break
            if flag:
                for j in range(len(X_0)):
                    if h - abs(X_0[j] - C_x) - abs(Y_0[j] - C_y) > 0:
                        flag = False
                        break
                if flag:
                    return C_x, C_y, h


C_x, C_y, H = solve(H, X_h, Y_h, X_0, Y_0)
print(C_x, C_y, H)

Submission status: Accepted

Solution code:
N=int(input())
x=[0]*N
y=[0]*N
h=[0]*N
for i in range(N):
    x[i],y[i],h[i]=map(int,input().split())
ansx=-1
ansy=-1
ansh=-1
for i in range(101):
    for j in range(101):
        P=True
        tmph=-1
        for k in range(N):
            if h[k]>0:
                tmph=h[k]+abs(i-x[k])+abs(j-y[k])
                break
        for l in range(N):
            if h[l]!=max(0,tmph-abs(i-x[l])-abs(j-y[l])):
                P=False
        if P==True:
            ansx=i
            ansy=j
            ansh=tmph
print(ansx,ansy,ansh)

Submission status: Accepted

Solution code:
N = int(input())
xyh = sorted([list(map(int,input().split())) for _ in range(N)], key = lambda x: -x[2])
for Cx in range(101):
  mx, my, mh = xyh[0]
  for Cy in range(101):
    H = mh + abs(mx - Cx) + abs(my - Cy)
    if(all(h == max(H - abs(x - Cx) - abs(y - Cy), 0) for x,y,h in xyh)):
      print(Cx, Cy, H)
      exit()

Submission status: Accepted

Solution code:
n=int(input())
p=[list(map(int,input().split()))for _ in range(n)]
ax,ay,ah=list(filter(lambda x:x[2],p))[0]
for x in range(101):
  for y in range(101):
    H=ah+abs(ax-x)+abs(ay-y)
    if all(max(H-abs(t[0]-x)-abs(t[1]-y),0)==t[2]for t in p):
      print(x,y,H)

Submission status: Accepted

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

def main():
    N = int(input())
    conditions = []
    for i in range(N):
        conditions.append(list(map(int, input().split())))

    conditions.sort(key = lambda v: v[2], reverse = True)

    rcx, rcy = -1, -1
    rH = 0
    for cx in range(101):
        for cy in range(101):
            f = True
            max_H = 10 ** 10
            H = 0
            for i in range(N):
                x, y, h = conditions[i]
                if 0 < h:
                    if H == 0:
                        H = h + abs(x - cx) + abs(y - cy)
                    elif H != h + abs(x - cx) + abs(y - cy):
                        f = False
                        break
                else:
                    if x == cx and y == cy:
                        f = False
                        break
                    max_H = min(max_H, abs(x - cx) + abs(y - cy))
                    if max_H < H:
                        f = False
                        break
            if f:
                rcx, rcy, rH = cx, cy, H
                break
        if 0 < rH:
            break


    print('{} {} {}'.format(rcx, rcy, rH))


if __name__ == '__main__':
    main()

Submission status: Accepted

Solution code:
n = int(input())
x = []
y = []
h = []
for i in range(n):
    a,b,c = map(int, input().split())
    x.append(a)
    y.append(b)
    h.append(c)
kk = h.index(max(h))
for i in range(101):
    for j in range(101):
        H = h[kk] + abs(x[kk] - i) + abs(y[kk] - j)
        for k in range(n):
            if h[k] > 0:
                if H != abs(x[k]-i)+abs(y[k]-j)+h[k]:
                    H = -1
            if h[k] == 0:
                if H > abs(x[k] - i) + abs(y[k] - j):
                    H = -1
        if H != -1:
            print(i, j, H)

Submission status: Accepted

Solution code:
from itertools import product

n = int(input())
query = []
for i in range(n):
    query.append(list(map(int, input().split())))
query.sort(key=lambda x: x[2], reverse=True)

for cx, cy in product(range(101), range(101)):
    h_pred = query[0][2] + abs(cx-query[0][0]) + abs(cy-query[0][1])
    flag = True
    for x,y,h in query[1:]:
        if max(h_pred - abs(x-cx) - abs(y-cy), 0) != h:
            flag =False
            break
    if flag:
        print(cx, cy, h_pred)
        exit()

Submission status: Accepted

Solution code:
def manhattan(i, j, x, y):
    # (i, j)中央点の座標，(x, y)既知の座標
    return abs(i-x) + abs(j-y)

def main(N, X, Y, H):
    cand = [0, 0, 0]
    for i in range(101):
        for j in range(101):
            # 既知座標１点を得て，中心座標の高さを決定する
            for k in range(N):
                if H[k] != 0:
                    x, y, h = X[k], Y[k], H[k]
                    hmax = h + manhattan(i, j, x, y)
                    break
            # 残り既知座標N-1点について，矛盾がないか確かめる
            for k in range(N):
                x, y, h = X[k], Y[k], H[k]
                if h == 0:
                    if hmax > manhattan(i, j, x, y):
                        break
                else:
                    if hmax - h != manhattan(i, j, x, y):
                        break
            else:
                if cand[2] < hmax:
                    cand = [i, j, hmax]
    return cand

N = int(input())
X, Y, H = [], [], []
for _ in range(N):
    x, y, h = map(int, input().split())
    X.append(x)
    Y.append(y)
    H.append(h)
i, j, hmax = main(N, X, Y, H)
print(str(i) + ' ' + str(j) + ' ' + str(hmax))

Submission status: Accepted

Solution code:
n = int(input())
infolist = []
for i in range(n):
    infolist.append([int(x) for x in input().split()])
center = []
for x in infolist:
    if x[2] != 0:
        x1, y1, h1 = x
        break
for i in range(101):
    for j in range(101):
        H = h1 + abs(x1-i) + abs(y1-j)
        if all(h == max((H - abs(x-i) - abs(y-j)) ,0) for x, y, h in infolist):
            print(i, j, H)

Submission status: Accepted

Solution code:
n = int(input())
A = [[int(i) for i in input().split()] for i in range(n)]
A.sort(reverse = True, key = lambda x: x[2])

for i in range(101):
    for j in range(101):
        px, py, ph = A[0] # 高さ最大
        H = ph + abs(px - i) + abs(py - j)
        if all(h == max(H - abs(x - i) - abs(y - j) , 0) for x, y, h in A):
            print(i, j, H)

Submission status: Accepted

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

def possible_height(cx, cy, infos):
    maxmin = 1
    minmax = 99999999999
    for i in infos:
        hmin, hmax = get_height(cx, cy, *i)
        maxmin = max(maxmin, hmin)
        minmax = min(minmax, hmax)
    if maxmin == minmax:
        return maxmin
    elif maxmin < minmax:  # Undetermined
        raise Exception
    else:  # Impossible
        return None

def get_height(cx, cy, xi, yi, hi):
    hmax = abs(cx - xi) + abs(cy - yi) + hi
    hmin = 1 if hi == 0 else hmax
    return hmin, hmax

def main():
    n = int(input())
    infos = []
    for i in range(n):
        x, y, h = map(int, input().split())
        infos.append((x, y, h))

    for cx in range(101):
        for cy in range(101):
            h = possible_height(cx, cy, infos)
            if h is not None:
                print(cx, cy, h)
                return
    raise Exception

main()

Submission status: Accepted

Solution code:
n = int(input())
A = [[int(i) for i in input().split()] for i in range(n)]
A.sort(reverse = True, key = lambda x: x[2])

for i in range(101):
    for j in range(101):
        px, py, ph = A[0]
        H = ph + abs(px - i) +abs(py - j)
        if all(h == max(H - abs(x - i) - abs(y - j) , 0) for x, y, h in A):
            print(i, j, H)

Submission status: Accepted

Solution code:
def main():
    n = int(input())
    x = []
    y = []
    h = []
    for i in range(n):
        xx, yy, zz = map(int, input().split())
        x.append(xx)
        y.append(yy)
        h.append(zz)
    for i in range(n):
        if h[i] != 0:
            idx = i
    for xx in range(101):
        for yy in range(101):
            H = h[idx] + abs(xx - x[idx]) + abs(yy - y[idx])
            flag = True
            for i in range(n):
                if h[i] != max(H - abs(xx - x[i]) - abs(yy - y[i]), 0):
                    flag = False
                    break
            if flag:
                print(xx, yy, H)
                return

    
if __name__ == '__main__':
    main()

Submission status: Accepted

Solution code:
n = int(input())
 
#zahyo[i][j], iはi番目の地点、j=0はx座標、j=1はy座標、j=2は高さhを表す
zahyo = [list(map(int,input().split())) for i in range(n)] 
 
for cx in range(101):
  for cy in range(101):
    flag =0
    for i in range(n):
      if zahyo[i][2]>0:
        H0 = abs(cx-zahyo[i][0])+abs(cy-zahyo[i][1])+zahyo[i][2]
        break
    for i in range(n):
      if zahyo[i][2] != max(0, H0-abs(cx-zahyo[i][0])-abs(cy-zahyo[i][1])):  
        flag=1
        break
    if flag==0:
      print(cx,cy,H0)
      exit()

Submission status: Accepted

Solution code:
N = int(input())
xyh = [[int(i) for i in input().split()] for i in range(N)]

tmpx,tmpy,tmph=0,0,0
for x,y,h in xyh:
    if h>0:
        tmpx,tmpy,tmph=x,y,h
        break

truecx,truecy,trueh=0,0,0
for cx in range(101):
    for cy in range(101):
        largeh=tmph+abs(tmpx-cx)+abs(tmpy-cy)
        flag=True
        for x,y,h in xyh:
            if h != max(largeh-abs(x-cx)-abs(y-cy),0):
                flag = False
                break
        if flag:
            truecx,truecy,trueh=cx,cy,largeh
            break
print(truecx,truecy,trueh)

Submission status: Accepted

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


def m():
    tmpx, tmpy, tmpr = 0, 0, 0
    for a,b,c in xyr:
        if c != 0:
            tmpx = a
            tmpy = b
            tmpr = c
            break

    for cx in range(0, 101):
        for cy in range(0, 101):
            h = max(0, tmpr + abs(tmpx - cx) + abs(tmpy - cy))
            f = 0
            for x, y, r in xyr:
                if not (r == max(h - abs(x - cx) - abs(y - cy), 0)):
                    f = 1
                    break
            if f == 0:
                return "{} {} {}".format(cx, cy, h)


print(m())

Submission status: Accepted

Solution code:
N = int(input().strip())
xyh = []
for i in range(0, N):
    xi, yi, hi= [int(a) for a in input().strip().split()]
    xyh.append((xi, yi, hi))

xyh.sort(key = lambda t: t[2], reverse = True)

def calc_H():
    for Cx in range(0, 101):
        for Cy in range(0, 101):
            H = -1
            for i in range(0, N):
                Hi = xyh[i][2] + abs(xyh[i][0]-Cx) + abs(xyh[i][1]-Cy)
                if H == -1:
                    H = Hi

                if xyh[i][2] == 0:
                    if H > Hi:
                        break
                elif H != Hi:
                    break

                if i == N-1:
                    return Cx, Cy, H

print(*calc_H())

Submission status: Accepted

Solution code:
def main():
    N = int(input())
    points = []
    for _ in range(N):
        x, y, h = map(int, input().split())
        points.append((x, y, h))

    for xx, yy, hh in points:
        if hh > 0:
            break
    for cx in range(101):
        for cy in range(101):
            f = True
            H = hh + abs(xx - cx) + abs(yy - cy)
            for x, y, h in points:
                if h != max(H - abs(x - cx) - abs(y - cy), 0):
                    f = False
                    break
            if f is True:
                print(cx, cy, H)
                return


if __name__ == '__main__':
    main()

Submission status: Accepted

Solution code:
N = int(input())
src = [tuple(map(int,input().split())) for i in range(N)]

cands = []
for cx in range(0,101):
    for cy in range(0,101):
        tmph = None
        for x,y,h in src:
            if h == 0: continue
            ch = h + abs(x-cx) + abs(y-cy)
            if ch < 0: break
            if tmph is None:
                tmph = ch
            elif tmph != ch:
                break
        else:
            cands.append((cx,cy,tmph))

for cx,cy,ch in cands:
    for x,y,h in src:
        if h != max(ch - abs(x-cx) - abs(y-cy), 0): break
    else:
        print(cx,cy,ch)
        exit()

Submission status: Accepted

Solution code:
def abc(n:int,lst:list):
    l0=list(filter(lambda x:x[2]==0,lst))
    l=list(filter(lambda x:x[2]!=0,lst))
    if len(l0):
        x0 =l[0][0]
        y0=l[0][1]
        h0 =l[0][2]
        ans=[]
        for x in range(101):
            for y in range(101):
                for i in range(len(l)):
                    if abs(x0-x)+abs(y0-y)-abs(l[i][0]-x)-abs(l[i][1]-y) == l[i][2]-h0:
                        if i ==len(l)-1:
                            for k in range(len(l0)):
                                if abs(l0[k][0]-x)+abs(l0[k][1]-y)>=h0+abs(x0-x)+abs(y0-y):
                                    if k == len(l0)-1:
                                        return x,y,h0+abs(x0-x)+abs(y0-y)
                                else:
                                    break
                    else:
                        break

    else:
        x0 =lst[0][0]
        y0=lst[0][1]
        h0 =lst[0][2]
        for x in range(101):
            for y in range(101):
                for i in range(1,n):
                    if abs(x0-x)+abs(y0-y)-abs(lst[i][0]-x)-abs(lst[i][1]-y) ==lst[i][2]-h0:
                        if i ==n-1:
                            return x,y,h0+abs(x0-x)+abs(y0-y)
                    else:
                        break
n = int(input())
lst = [list(map(int,input().split())) for i in range(n)]
x,y,h =abc(n,lst)
print(x,y,h)