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:
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:
                            ans.append([x,y,h0+abs(x0-x)+abs(y0-y)])
                    else:
                        break
        for xyh in ans:
            for i in range(len(l0)):
                if abs(l0[i][0]-xyh[0])+abs(l0[i][1]-xyh[1])>=xyh[2]:
                    if i == len(l0)-1:
                        return xyh
                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)

Submission status: Accepted

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

for i in range(101):
    for j in range(101):
        px, py, ph = xyh[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 xyh):
            print(i, j, H)

Submission status: Accepted

Solution code:
N = int(input())
X = list()
Y = list()
H = list()
i = 0
for n in range(0,N):
    S = list(map(int,input().split()))
    X.append(S[0])
    Y.append(S[1])
    H.append(S[2])
for x in range(0,101):
    for y in range(0,101):
        while H[i] == 0:
            i = i+1 
            if i == N-1:
                break
        else:
            sub = abs(x - X[i]) + abs(y - Y[i]) + H[i]
        for n in range(0,N):
            h = sub - abs(x-X[n]) - abs(y-Y[n])
            if not H[n] == max(h,0):
                break
            else:
                if n == N-1:
                    print(x, y, sub)

Submission status: Accepted

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

for i in range(N):
    ent = input().split()
    xyh.append((int(ent[0]), int(ent[1]), int(ent[2])))

sortedxyh = sorted(xyh, key=lambda x:int(x[2]))

pointA = None
pointB = None
for x in xyh:
    if x[2] != 0:
        if pointA == None:
            pointA = x
        else:
            pointB = x
            break

endflg = False
if pointB == None:
    # 1点しか高さのある点がないケース
    print(str(pointA[0]) + ' ' + str(pointA[1]) + ' ' + str(pointA[2]))
else:
    # 2点あれば全探索で計算出来る?
    # 高さ算出
    for cx in range(0, 101):
        for cy in range(0, 101):
            AH = pointA[2] + max( ( abs(pointA[0] - cx) + abs(pointA[1] - cy) ), 0)
            BH = pointB[2] + max( ( abs(pointB[0] - cx) + abs(pointB[1] - cy) ), 0)
            if AH == BH and AH != 0 and BH != 0:
                H = AH
                continueflg = False
                for other in xyh:
                    if other[2] != max((H - abs(other[0] - cx) - abs(other[1] - cy)), 0):
                        continueflg = True
                        break
                if continueflg:
                    continue
                print(str(cx) + ' ' + str(cy) + ' ' + str(H))
                endflg = True
                break
            else:
                continue
        if endflg:
            break

Submission status: Accepted

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

for i in range(N):
    if data[i][2] >0:
        base=i
        break

for cx in range(101):
    for cy in range(101):
        h = data[base][2] + abs(cx-data[base][0]) + abs(cy - data[base][1])
        flag=0
        for i in range(N):
            if data[i][2] != max(h - abs(cx-data[i][0]) - abs(cy-data[i][1]),0):
                flag=1
                break
        if flag==0:
            ans = [cx,cy,h]
            
print('{0[0]} {0[1]} {0[2]}'.format(ans))

Submission status: Accepted

Solution code:
N = int(input())
data = [[0 for i in range(3)] for j in range(N)]
for i in range(N):
    data[i][0],data[i][1],data[i][2] = [int(s) for s in input().split()]


for p in data:
    if p[2] != 0:
        base_x = p[0]
        base_y = p[1]
        base_height = p[2]


for Cx in range(0,101):
    for Cy in range(0,101):
        height = abs(base_x-Cx)+abs(base_y-Cy)+base_height
        for p in data:
            if p[2] != max([height-abs(Cx-p[0])-abs(Cy-p[1]),0]):
                break
        else:
            print(str(Cx)+' '+str(Cy)+' '+str(height))
            exit()

Submission status: Accepted

Solution code:
n = int(input())
hxy = []
for i in range(n):
    x, y, h = map(int, input().split())
    hxy.append([h, x, y])
    
hxy.sort(reverse=True)

for i in range(101):
    for j in range(101):
        h0, x0, y0 = hxy[0]
        H = h0 + abs(x0-i) + abs(y0-j)
        if all(h == max(H - abs(x-i) - abs(y-j), 0) for h, x, y in hxy):
            print(i, j, H)
            break

Submission status: Accepted

Solution code:
n=int(input())
l=[]
for i in range(n):
    x,y,h = map(int, input().split())
    l.append([x,y,h])
l.sort(reverse=True, key=lambda x: x[2])
for i in range(101):
    for j in range(101):
        px, py, ph = l[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 l):
            print(i,j,H)
            break

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())
for a in range(101):
    for b in range(101):
        hset = set()
        for i in range(n):
            if h[i] != 0:
                hset.add(h[i] + abs(x[i]-a) + abs(y[i]-b))
        if len(hset) == 1:
            height = hset.pop()
            check = True
            for i in range(n):
                if h[i] == 0:
                    if height - abs(x[i]-a) - abs(y[i]-b) > 0:
                        check = False
                        break
            if check:
                print(a,b,height)
                exit()
print('ERROR EXIT')

Submission status: Accepted

Solution code:
N = int(input())
S = [[int(i) for i in input().split()] for j in range(N)]
SS = sorted(S,key=lambda x: x[2], reverse=True)

#(x, y)を(0,0)から(100,100)まで試す
def firstlook(si, kohod): 
    for x in range(0, 100+1):
        for y in range(0, 100+1):
            h = si[2]+abs(si[0]-x)+abs(si[1]-y)
            kohod[(x,y)] = h
    return kohod

def lastlook(si, kohod):
    for (x, y) in list(kohod.keys()):
        h = max(kohod[(x,y)]-abs(si[0]-x)-abs(si[1]-y),0)
        if si[2] != h:
            del kohod[(x,y)]
    return kohod

ans = firstlook(SS[0], dict())
for Si in SS[1:]:
    ans = lastlook(Si, ans)

[xy] = list(ans.keys())
print(str(xy[0]) + " " + str(xy[1]) + " "+ str(ans[xy]))

Submission status: Accepted

Solution code:
W = 101

def solve(xyh):
    for bx, by, bh in xyh:
        if bh > 0:
            break
    for yy in range(W):
        for xx in range(W):
            H = bh + abs(bx - xx) + abs(by - yy)
            for x, y, h in xyh:
                if max(H - abs(xx - x) - abs(yy - y), 0) != h:
                    break
            else:
                return (xx, yy, H)

N = int(input())
xyh = [tuple(map(int, input().split())) for i in range(N)]
print(*solve(xyh))

Submission status: Accepted

Solution code:
N=input()

Data=[]
for i in range(N):
    Data.append(map(int,raw_input().split()))
    
Data.sort(key=lambda x:x[2], reverse=True)
for i in range(0,101):
    for j in range(0,101):
        H=Data[0][2]+abs(Data[0][0]-i)+abs(Data[0][1]-j)
        k=1
        while k<N:
            if (H-abs(Data[k][0]-i)-abs(Data[k][1]-j)<=0 and Data[k][2]==0)\
             or H==Data[k][2]+abs(Data[k][0]-i)+abs(Data[k][1]-j):
                k+=1
            else:
                break
        if k==N:
            print i,j,H
            exit()

Submission status: Accepted

Solution code:
n = int(input())
positions = [list(map(int, input().split())) for _ in range(n)]
for position in positions:
  if position[2] != 0:
    base = position
    break
base_height = base[2]
base_x = base[0]
base_y = base[1]
for x in range(101):
  for y in range(101):
    height = abs(base_x-x)+abs(base_y-y)+base_height
    for position in positions[:]:
      if position[2] != max([height-abs(x-position[0])-abs(y-position[1]),0]):
        break
    else:
      print(str(x) + ' ' + str(y) + ' ' + str(height))
      exit()

Submission status: Accepted

Solution code:
N = int(input())

xyh = []

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

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

for i in range(101):
    for j in range(101):
        px, py, ph = xyh[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 xyh):
            print(i,j,H)
            break

Submission status: Accepted

Solution code:
import sys
import itertools

cols = []
for line in sys.stdin:
  col = line.strip().split(' ')
  col = [int(c) for c in col]
  cols.append(col)

cols = cols[1:]
for cx,cy in itertools.product(list(range(101)), list(range(101))):
  H, H_max, flag = None, None, True
  for x,y,h in cols:
    if h <= 0:
      tmp_H_max = abs(x-cx) + abs(y-cy)
      if tmp_H_max < 1:
        flag = False
        break
      else:
        H_max = min(H_max, tmp_H_max) if H_max else tmp_H_max
      if H and H_max < H:
        flag = False
        break
    else:
      tmp_H = h + abs(x-cx) + abs(y-cy)
      if not H:
        H = tmp_H
      elif H and H != tmp_H:
        flag = False
        break
      if H_max and H_max < tmp_H:
        flag = False
        break
  if flag:
    print(cx,cy,H)

Submission status: Accepted

Solution code:
n = int(input())

xyh = []

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

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

for i in range(101):
    for j in range(101):
        px, py, ph = xyh[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 xyh):
            print(i, j, H)
            break

Submission status: Accepted

Solution code:
n = int(input())
A = [list(map(int,input().split())) for _ in range(n)]
X = [0,0,0]
for i in range(n):
    if A[i][2]>0:
        X = A[i]
        break


for x in range(101):
    for y in range(101):
        h = X[2] + abs(x-X[0]) + abs(y-X[1])
        flag = 1
        for i in range(n):
            if A[i][2] != max(h - abs(x-A[i][0]) - abs(y-A[i][1]),0):
                flag = 0
        if flag == 1:
            print(x,y,h)

Submission status: Accepted

Solution code:
#coding:utf-8

def validate(N, points, c_x, c_y):
    #estimate height
    for n in range(N):
        h = points[n][2]
        if h != 0:
            x = points[n][0]
            y = points[n][1]
            estimated_height = h + abs(c_x - x) + abs(c_y - y)

    #validate height
    for n in range(N):
        x = points[n][0]
        y = points[n][1]
        h = points[n][2]
        height = max(estimated_height - abs(c_x - x) - abs(c_y - y), 0)

        if h != height:
            return -1
    return estimated_height

if __name__ == "__main__":
    N = int(input())
    points = [None] * N
    for n in range(N):
        x, y, h = map(int, input().split())
        points[n] = [x, y, h]

    candidates = [i for i in range(101)]
    for c_x in candidates:
        for c_y in candidates:
            height = validate(N, points, c_x, c_y)
            if height != -1:
                print(c_x, c_y, height)
                break

Submission status: Accepted

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

for i in range(101):
  for j in range(101):
    for k in range(N):
      if xyh[k][2] != 0:
        H = xyh[k][2] + abs(i-xyh[k][0]) + abs(j-xyh[k][1])
        break
    is_h = True
    for k in range(N):
      if max(0, H-abs(i-xyh[k][0])-abs(j-xyh[k][1])) != xyh[k][2]:
        is_h = False
        break
    if is_h:
      print(i, j, H)

Submission status: Accepted

Solution code:
N = int(input())

arr = []

for i in range(N):
    arr.append(list(map(int, input().split())))
    
for x in range(101):
    for y in range(101):
        for i in range(N):
            if arr[i][2]:
                H = arr[i][2] + abs(x-arr[i][0]) + abs(y-arr[i][1])
                break
        ok = True
        for i in range(N):
            price = H-abs(x-arr[i][0])-abs(y-arr[i][1])
            if max(price,0) != arr[i][2]:
                ok = False
        if ok :
            print(x,y,H)

Submission status: Accepted

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

    if h == 0:
        continue
    XYHA.append([x,y,h])

if len(XYHA) == 1:
    print(XYHA[0][0],XYHA[0][1],XYHA[0][2])
    exit()

for i in range(101):
    for j in range(101):
        HC = max(XYHA[0][2] + abs(XYHA[0][0] - i) + abs(XYHA[0][1] - j), 0)
        for k in range(1, len(XYHA)):

            H = max(XYHA[k][2] + abs(XYHA[k][0] - i) + abs(XYHA[k][1] - j), 0)

            if HC != H:
                break
            elif k == len(XYHA) - 1:
                print(i,j,HC)
                exit()

Submission status: Accepted

Solution code:
N = int(input())
 
XYHA = []
 
for i in range(N):
    x,y,h = map(int,input().split())
    if h == 0:
        continue
    XYHA.append([x,y,h])

for i in range(101):
    for j in range(101):
        HC = XYHA[0][2] + abs(XYHA[0][0] - i) + abs(XYHA[0][1] - j)
        for k in range(1, len(XYHA)):

            H = XYHA[k][2] + abs(XYHA[k][0] - i) + abs(XYHA[k][1] - j)

            if HC != H:
                break
            elif k == len(XYHA) - 1:
                print(i,j,HC)
                exit()

print(XYHA[0][0],XYHA[0][1],XYHA[0][2])

Submission status: Accepted

Solution code:
N = int(input())
 
info = []
 
for i in range(N):
    x,y,h = map(int,input().split())
    if h == 0:
        N -= 1
        continue
    info.append([x,y,h])
 
for i in range(101):
    for j in range(101):
        H_0 = info[0][2] + abs(info[0][0] - i) + abs(info[0][1] - j)
        
        for k in range(1, N):
            H = info[k][2] + abs(info[k][0] - i) + abs(info[k][1] - j)
            
            if H_0 != H:
                break
            elif k == N - 1:
                print(i,j,H_0)
                exit()
 
print(info[0][0],info[0][1],info[0][2])

Submission status: Accepted

Solution code:
N = int(input())
info = []
for i in range(N):
    x,y,h = map(int,input().split())
    if h == 0:
        N -= 1
        continue
    info.append([x,y,h])
for i in range(101):
    for j in range(101):
        H_0 = info[0][2] + abs(info[0][0] - i) + abs(info[0][1] - j)
        for k in range(1,N):
            H = info[k][2] + abs(info[k][0] - i) + abs(info[k][1] - j)
            if H_0 != H:
                break
            elif k == N-1:
                print(i,j,H_0)
                exit()
print(info[0][0],info[0][1],info[0][2])

Submission status: Accepted

Solution code:
N=int(input())
A=[[]for i in range(N)]
for i in range(N):
    a,b,c=map(int,input().split())
    A[i].append(a)
    A[i].append(b)
    A[i].append(c)
A.sort(key=lambda x:x[2],reverse=True)
c=0
h=0
X=0
Y=0
for x in range(101):
    for y in range(101):
        c=0
        for i in range(N):
            H=abs(A[i][0]-x)+abs(A[i][1]-y)+A[i][2]
            if H>=abs(A[i][0]-x)+abs(A[i][1]-y):
                break
        for i in range(N):
            if max(H-abs(A[i][0]-x)-abs(A[i][1]-y),0)!=A[i][2]:
                c=1
                break
        if c==0:
            h=H
            X=x
            Y=y
            break
    if c==0:
        break
print(X,Y,h)

Submission status: Accepted

Solution code:
n=int(input())

x=[[int(i) for i in input().split()] for i in range(n)]
#print(x)
cnt=0
for m in range(n):
  if x[m][2]>0:
    cnt+=1
    ii=m
    
#print(ii,cnt)

def hight(a,b,x,y,z):
  h=z+abs(x-a)+abs(y-b)
  return h

for i in range(101):
  for j in range(101):
    flag=0
    for k in range(n):
      if x[k][2]>0:
        if hight(i,j,x[ii][0],x[ii][1],x[ii][2])==hight(i,j,x[k][0],x[k][1],x[k][2]):
          flag+=1
      else:
        if hight(i,j,x[ii][0],x[ii][1],x[ii][2]) > hight(i,j,x[k][0],x[k][1],x[k][2]):
          flag=0
     
    if flag==cnt:
      ans1=i
      ans2=j
      ans3=hight(i,j,x[ii][0],x[ii][1],x[ii][2])
      
print(ans1,ans2,ans3)
#print(flag)

Submission status: Accepted

Solution code:
n = (int)(input())

x = []
y = []
h = []

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

f = False
for i in range(0, 100+1):
    for j in range(0, 100+1):
        for k in range(n):
            if h[k] != 0:
                ch = h[k] + abs(i-x[k]) + abs(j-y[k])
                break
        if all(max(ch-abs(i-x[k]) - abs(j-y[k]), 0) == h[k] for k in range(n)):
            print(i, j, ch)
            exit()

Submission status: Accepted

Solution code:
n = int(input())
xyh = [tuple(map(int, input().split())) for _ in range(n)]

for i in range(n):
    if xyh[i][2] > 0:
        ca = i

for x in range(0, 101):
    for y in range(0, 101):
        flag = True
        H = xyh[ca][2] + abs(xyh[ca][0] - x) + abs(xyh[ca][1] - y)
        for xx, yy, hh in xyh:
            h = max(H - abs(xx - x) - abs(yy - y), 0)
            if hh != h:
                flag = False
                break
        if flag:
            print(x, y, H)
            exit()

Submission status: Accepted

Solution code:
import numpy as np
import itertools
import sys

N = int(input())
xyh = [list(map(int,input().split())) for i in range(N)]
sorce = np.array(range(101))
xyh.sort(key=lambda x:x[2],reverse=True)

for ar in itertools.product(sorce,repeat=2):
    H = 0
    cnt = 0
    f = 0
    for i in xyh:
        X,Y = abs(np.subtract( [ar[0],ar[1]] , [i[0],i[1]] ))
        if f == 0:
            H = X+Y+i[2]
            f = 1
        if i[2] == max((H-X-Y),0):
            cnt += 1
        else:
            break
        if cnt == N:
            print(ar[0],ar[1],H)
            sys.exit()

Submission status: Accepted

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

N = int(input())
x = [None] * N
y = [None] * N
h = [None] * N
for i in range(N):
    x[i], y[i], h[i] = map(int, input().split())


def distance(a,b):
    a_x = a[0]
    a_y = a[1]
    b_x = b[0]
    b_y = b[1]

    return abs(a_x - b_x) + abs(a_y - b_y)


for cx in range(101):
    for cy in range(101):
        ans = True
        c = [cx, cy]
        for i in range(N):
            if h[i] != 0:
                ch = distance(c, [x[i], y[i]]) + h[i]
                break
        # ch = distance(c, [x[0], y[0]]) + h[0]  # cx, cyを仮定するとchが定まる
        for i in range(N):
            if max([ch - distance(c, [x[i], y[i]]), 0]) != h[i]:
                ans = False
                break
        if ans:
            break
    if ans:
        break

print(" ".join(list(map(str, [cx, cy, ch]))))

Submission status: Accepted

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

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

hxy.sort(reverse=True)

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

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)
    if c >0:
        data=[a,b,c]

for ans_x in range(101):
    for ans_y in range(101):
        ans_h = data[2]+abs(ans_x-data[0])+abs(ans_y-data[1])
        i = 0
        while i < n:
            if h[i]!= max(0,ans_h-abs(x[i]-ans_x)-abs(y[i]-ans_y)):
                break
            else:
                i += 1
        if i == n:
            print(ans_x,ans_y,ans_h)

Submission status: Accepted

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

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

hxy.sort(reverse=True)
    
for i in range(101):
    for j in range(101):
        h, x, y = hxy[0]
        H = h + abs(x - i) + abs(y - j)
        if all(h == max(H - abs(x - i) - abs(y - j), 0) for h, x, y in hxy):
            print(i, j, H)

Submission status: Accepted

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

for i in range(n):
    x, y, h = map(int, input().split())
    points.append((h, x, y))
    
points.sort(reverse=True)
    
for i in range(101):
    for j in range(101):        
        ph, px, py = points[0]
        H = ph + abs(px-i) + abs(py-j)
        if all(ph == max(H - abs(px-i) - abs(py-j), 0) for ph, px, py in points):
            print(i, j, H)

Submission status: Accepted

Solution code:
N=int(input())

A=[]
for i in range(N):
    x,y,h=map(int,input().split())
    A.append([h,x,y])
A.sort(reverse=True)

for i in range(101):
    for j in range(101):
        for k in range(N):
            H = A[k][0] + abs(j-A[k][1]) + abs(i-A[k][2])
            flg = True
            for l in A:
                if l[0]!=max(0,H-abs(j-l[1])-abs(i-l[2])):
                    flg = False
                    break
            if flg == True:
                print(j,i,H)
                exit()

Submission status: Accepted

Solution code:
N=int(input())
z=[]
for i in range(N):
    z.append(list(map(int,input().split())))
h=max(zz[2] for zz in z)
while(1):
    flag=1
    for x in range(101):
        for y in range(101):
            for zz in z:
                if max(h-abs(zz[0]-x)-abs(zz[1]-y),0) != zz[2]:
                    break
            else:
                print(x,y,h)
                exit()
    h+=1

Submission status: Accepted

Solution code:
import numpy as np
import itertools

N = int(input())
xi,yi,hi = [], [], []
for _ in range(N):
    x,y,h = map(int, input().split())
    xi.append(x)
    yi.append(y)
    hi.append(h)

max_hi = max(hi)
max_i = hi.index(max_hi)
max_xi = xi[max_i]
max_yi = yi[max_i]

xi = np.array(xi)
yi = np.array(yi)
hi = np.array(hi)

for Cx,Cy in itertools.product(range(101), repeat=2):
    H = abs(Cx - max_xi) + abs(Cy - max_yi) + max_hi
    hi_ = np.fmax( H - np.absolute(Cx-xi) - np.absolute(Cy-yi), 0)
    diff = hi-hi_
    if np.all(diff==0):
        print("{} {} {}".format(Cx, Cy, H))
        exit(0)

Submission status: Accepted

Solution code:
N = int(input())
List = [[int(i) for i in input().split()] for _ in range(N)]
for xt, yt, ht in List:
    if ht > 0:
        break
for px in range(0, 101):
    for py in range(0, 101):
        H = ht + abs(px - xt) + abs(py - yt)
        if len(list(filter(lambda x: x[2] != max(H - abs(px - x[0]) - abs(py - x[1]), 0), List))) == 0:
            print(px, py, H)
            break
    else:
        continue
    break

Submission status: Accepted

Solution code:
#!/mnt/c/Users/moiki/bash/env/bin/python
N = int(input())
hlist = []
for i in range(N):
    x,y,h = list(map(int, input().split()))
    hlist.append((x,y,h))

for i in range(101):
    for j in range(101):
        cx = i
        cy = j
        plist = [x for x in hlist if x[2] > 0]
        plist = sorted(plist, key=lambda x: x[2])
        if len(plist) == 0:
            continue

        for hpp in plist:
            hm = hpp[2] + abs(hpp[0]-cx) + abs(hpp[1]-cy)
            if hm < 1:
                continue
            ok = True
            for l in hlist:
                if l[2] != max((hm - abs(l[0] - cx) - abs(l[1] - cy)), 0):
                    ok = False
                    break
            if ok:
                print("{0} {1} {2}".format(cx, cy, hm))
                exit(0)

Submission status: Accepted

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


def isvalid(i, j):
    H = -1
    for p, q, h in query:
        if h != 0:
            H = h + abs(p - i) + abs(q - j)
            break

    for p, q, h in query:
        if H == -1 and h != 0:
            H = h + abs(p - i) + abs(q - j)

        if h != max(H - abs(p - i) - abs(q - j), 0):
            return -1
    return H


for i in range(101):
    for j in range(101):
        H = isvalid(i, j)
        if H >= 1:
            print(i, j, H)
            exit()

Submission status: Accepted

Solution code:
i = lambda: list(map(int, input().split()))
N, = i()
M = [i() for j in range(N)]
k = -1
for k in range(len(M)):
    if M[k][2] > 0:
        break
for Cx in range(101):
    for Cy in range(101):
        H = abs(M[k][0] - Cx) + abs(M[k][1] - Cy) + M[k][2]
        if all([False for d in M if d[2] != max(H - abs(d[0] - Cx) - abs(d[1] - Cy), 0)]):
            print(Cx, Cy, H)
            break

Submission status: Accepted

Solution code:
N = int(input())

array = []

for i in range(N):
    array.append(list(map(int,input().split())))

test = []

t = []

for x in range(101):
    for y in range(101):
        H = []
        for i in array:
            if i[2] > 0:
                H_i = max(abs(i[0]-x)+abs(i[1]-y)+i[2],0)
                H.append(H_i)
        Hset = set(H)
        H = list(Hset)[0]
        if(len(Hset)==1 and H>=0):
            t.append([x,y,H])

if len(t) >= 2:
    t = []
    for x in range(101):
        for y in range(101):
            H = []
            for i in array:
                if True:
                    H_i = max(abs(i[0]-x)+abs(i[1]-y)+i[2],0)
                    H.append(H_i)
            Hset = set(H)
            H = list(Hset)[0]
            if(len(Hset)==1 and H>=0):
                t.append([x,y,H])
            
print("{0[0]} {0[1]} {0[2]}".format(t[0]))

Submission status: Accepted

Solution code:
N = int(input())
X, Y, H = zip(*[tuple(map(int, input().split(" "))) for _ in range(N)])

for i in range(N):
	if H[i] <= 0:
		continue
	std = i
	break
# print(X[std], Y[std])
for cy in range(101):
	for cx in range(101):
		ch = H[std] + abs(cx-X[std]) + abs(cy-Y[std])
		flag = True
		for i in range(N):
			if max(0, ch - abs(cx-X[i]) - abs(cy-Y[i])) != H[i]:
				flag = False
				# break
			# print(ch, cx, cy, X[i], Y[i], ch - abs(cx-X[i]) - abs(cy-Y[i]), H[i])
		if flag:
			print(cx, cy, ch)
			exit()

Submission status: Accepted

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

for i in c:
    if i[2] > 0:
        o = i
        break

for cx in range(101):
    for cy in range(101):
        H = o[2] + abs(o[0] - cx) + abs(o[1] - cy)
        f = True
        for i in c:
            x, y, h = i[0], i[1], i[2]
            if h != max(0, H - abs(x - cx) - abs(y - cy)):
                f = False
                break
        if f:
            print(cx, cy, H)
            exit()

Submission status: Accepted

Solution code:
N=int(input())

A=[]
for i in range(N):
    x,y,h=map(int,input().split())
    A.append([h,x,y])
A.sort(reverse=True)
#print(A)



for h in range(101):
    for w in range(101):
        H=A[0][0]+abs(A[0][1]-(w))+abs(A[0][2]-(h))
        cnt=0
        for t in range(1,N):
            if A[t][0]==max(0,H-abs(A[t][1]-(w))-abs(A[t][2]-(h))):
                cnt+=1
            else:
                break
        if cnt==N-1:
            print(w,h,H)
            exit()

Submission status: Accepted

Solution code:
data = [tuple(map(int, input().split())) for _ in range(int(input()))]
o = None
for i in data:
    if i[2] > 0:
        o = i
        break
hs = {}

for cx in range(101):
    for cy in range(101):
        H = o[2] + abs(o[0] - cx) + abs(o[1] - cy)
        ok = True
        for d in data:
            h = max(H - abs(d[0] - cx) - abs(d[1] - cy), 0)
            if h != d[2]:
                ok = False
                break
        if ok:
            print(cx,cy,H)
            exit(0)

Submission status: Accepted

Solution code:
from itertools import product

data = [map(int, raw_input().split()) for _ in range(input())]

for cx, cy in product(range(101), repeat=2):
    ch = next(h + abs(cx - x) + abs(cy - y) for x, y, h in data if h != 0)
    if all(max(0, ch - abs(cx - x) - abs(cy - y)) == h for x, y, h in data):
        print cx, cy, ch
        break

Submission status: Accepted

Solution code:
n = int(input())

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

sam_x, sam_y, sam_h = next((x, y, h) for x, y, h in clues if h > 0)

centers = [(x, y) for x in range(101) for y in range(101)]
for cx, cy in centers:
    ch = sam_h + abs(sam_x - cx) + abs(sam_y - cy)
    identified = True
    for x, y, h in clues:
        if h != max(ch - abs(x - cx) - abs(y - cy), 0):
            identified = False
            break
    if identified:
        print(cx, cy, ch)
        exit()

Submission status: Accepted

Solution code:
n = int(input())

clues = []
for i in range(n):
    clues.append(tuple(map(int, input().split())))

sam_x, sam_y, sam_h = next((x, y, h) for x, y, h in clues if h > 0)

centers = [(x, y) for x in range(101) for y in range(101)]
for cx, cy in centers:
    ch = sam_h + abs(sam_x - cx) + abs(sam_y - cy)
    identified = True
    for x, y, h in clues:
        if h != max(ch - abs(x - cx) - abs(y - cy), 0):
            identified = False
            break
    if identified:
        print(cx, cy, ch)
        exit()