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 .

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

x=[[int(i) for i in input().split()] for i in range(n)]

cnt=0
for m in range(n):
  if x[m][2]>0:
    cnt+=1
    ii=m
    


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)

Solution (Python):
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()

Solution (Python):
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()

Solution (Python):
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()

Solution (Python):


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

Solution (Python):
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)

Solution (Python):
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)

Solution (Python):
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)

Solution (Python):
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)

Solution (Python):
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()

Solution (Python):
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

Solution (Python):
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)

Solution (Python):
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

Solution (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)

Solution (Python):
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)

Solution (Python):
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()

Solution (Python):
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

Solution (Python):
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]))

Solution (Python):
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

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
				
			
		if flag:
			print(cx, cy, ch)
			exit()

Solution (Python):
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()

Solution (Python):
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 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()

Solution (Python):
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)

Solution (Python):
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

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

clues = [tuple(map(int, input().split()))
         for _i in range(n)]
good_clue = next(clue for clue in clues if clue[2] > 0)

centers = [(x, y)
           for x in range(101)
           for y in range(101)]
for cx, cy in centers:
    ch = good_clue[2] \
         + abs(good_clue[0] - cx) \
         + abs(good_clue[1] - cy)

    if all(h == max(ch - abs(x - cx) - abs(y - cy), 0)
           for x, y, h in clues):
        print(cx, cy, ch)
        break

Solution (Python):
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()

Solution (Python):
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()

Solution (Python):
import sys
n = int(input())
xyh = []
fxyh = []
for _ in range(n):
    xyh.append(list(map(int, input().split())))
    if xyh[-1][2]:
        fxyh = xyh[-1]


for i in range(100 + 1):
    for j in range(100 + 1):
        h = fxyh[2] + abs(fxyh[0] - i) + abs(fxyh[1] - j)
        if 1 > h:
            continue
        ok = True
        for k in range(n):
            if xyh[k][2] != max(0, h - abs(xyh[k][0] - i) - abs(xyh[k][1] - j)):
                ok = False
                break
        if ok:
            print(str(i) + ' ' + str(j) + ' ' + str(h))
            sys.exit(0)

Solution (Python):
def inpl(): return [int(i) for i in input().split()]

N = int(input())
xyh = []
for _ in range(N):
    xyh.append(inpl())
for x, y, h in xyh:
    if h:
        tx, ty, th = x, y, h
        break
    
for i in range(101):
    for j in range(101):
        cx, cy, ch  = i, j, (th + abs(i-tx) + abs(j-ty))
        for kx, ky, kh in xyh:
            if max(0, ch - abs(cx-kx) - abs(cy-ky)) != kh:
                break
        else:
            print(cx, cy, ch)
            break
    else:
        continue
    break

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

l = []
a = {}
b = {}

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

for cx in range(100+1):
    for cy in range(100+1):
              
        count = 0
        preheight = abs(l[0][0]-cx) + abs(l[0][1]-cy) + l[0][2]

        for ll in l :
            height = abs(ll[0]-cx) + abs(ll[1]-cy) + ll[2] 
            if preheight != height:
                break
            count = count + 1

        if count >= len(l) :
            if preheight in a:
                a[preheight] += 1
                b[preheight] = [cx,cy]
            else:
                a[preheight] = 1
                b[preheight] = [cx,cy]

for ans in a.keys() :
    if a[ans] == 1 :
        print(b[ans][0],b[ans][1],ans)
        exit(0)

Solution (Python):
N = int(input())

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

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

for cx in range(101):
	for cy in range(101):
		x, y, h = xyhs[0]
		H = h + abs(x - cx) + abs(y - cy)
				
		for xyh in xyhs[1:]:
			x, y, h = xyh

			if h == 0:
				if H > abs(x - cx) + abs(y - cy):
					break
			else:
				if H != h + abs(x - cx) + abs(y - cy):
					break
		else:
			if H < 1:
				H = 1
			print(cx, cy, H)
			exit()

Solution (Python):
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())

C_x = C_y = H = 0


for i in range(N):
    for c_x in range(101):
        for c_y in range(101):
            H = h[i] + abs(x[i] - c_x) + abs(y[i] - c_y)

            for j in range(N):
                if h[j] == max(H - abs(x[j] - c_x) - abs(y[j] - c_y), 0):
                    continue
                break

            else:
                C_x = c_x
                C_y = c_y
                break
            continue
        else:
            continue
        break
    else:
        continue
    break

else:
    print('No!')

print(C_x, C_y, H)

Solution (Python):
n = int(input())
x = []
y = []
h = []
for i in range(n):
    X, Y, H = map(int, input().split())
    x.append(X)
    y.append(Y)
    h.append(H)

INF = float('inf')
for cx in range(101):
    for cy in range(101):
        H = INF
        Hmax = INF
        for i in range(n):
            if h[i] > 0 and H == INF:
                H = h[i] + abs(x[i] - cx) + abs(y[i] - cy)
            elif h[i] > 0 and H != h[i] + abs(x[i] - cx) + abs(y[i] - cy):
                break
            elif h[i] == 0:
                Hmax = min(Hmax, abs(x[i] - cx) + abs(y[i] - cy))
        else:
            if H <= Hmax:
                print(cx, cy, H)
                exit()
            elif H == INF and Hmax == 1:
                print(cx, cy, 1)
                exit()

Solution (Python):
N = int(input())
L = [list(map(int, input().split())) for k in range(N)]
m = 0
for l in L:
    m = max(m,l[2])

for x in range(101):
    for y in range(101):
        for h in range(m,m+101):
            f = 1
            for l in L:
                if l[2]!=max(h-abs(l[0]-x)-abs(l[1]-y),0):
                    f = 0
                    break
            if f:
                print(x,y,h)
                exit(0)

Solution (Python):
import sys
stdin = sys.stdin

sys.setrecursionlimit(10**5)

def li(): return map(int, stdin.readline().split())
def li_(): return map(lambda x: int(x)-1, stdin.readline().split())
def lf(): return map(float, stdin.readline().split())
def ls(): return stdin.readline().split()
def ns(): return stdin.readline().rstrip()
def lc(): return list(ns())
def ni(): return int(stdin.readline())
def nf(): return float(stdin.readline())

n = ni()
xyh = []
hmax = 0
xmax = -1
ymax = -1
for _ in range(n):
    x,y,h = li()
    if h > hmax:
        hmax = h
        xmax = x
        ymax = y
        
    xyh.append((x,y,h))
    
xans = -1
yans = -1
hans = -1
flag = False
    
for x in range(101):
    for y in range(101):
        hcent = hmax + abs(xmax-x) + abs(ymax-y)
        consis = True
        
        for xi,yi,hi in xyh:
            if hi != max(0, hcent - abs(x-xi) - abs(y-yi)):
                consis = False
                
        if not consis:
            continue
                
        if consis:
            xans = x
            yans = y
            hans = hcent
            
            flag = True
            break
            
    if flag:
        break
            
            
print(xans, yans, hans)

Solution (Python):
N = int(input())
xyh = []
for _ in range(N):
    x, y, h = map(int, input().split())
    if h != 0:
        xyh.append([x, y, h])

if len(xyh) == 1:
    Cx, Cy, H = xyh[0][0], xyh[0][1], xyh[0][2]

elif len(xyh) == 2:
    if xyh[0][2] > xyh[1][2]:
        Cx, Cy, H = xyh[0][0], xyh[0][1], xyh[0][2]
    else:
        Cx, Cy, H = xyh[1][0], xyh[1][1], xyh[1][2]

else:
    flag = False
    for i in range(101):
        for j in range(101):
            sampleH = xyh[0][2] + abs(i-xyh[0][0]) + abs(j-xyh[0][1])
            for k in range(1, len(xyh)):
                flag = True
                if xyh[k][2] + abs(i-xyh[k][0]) + abs(j-xyh[k][1]) != sampleH:
                    flag = False
                    break
            if flag:
                Cx, Cy, H = i, j, sampleH
                break
        if flag:
            break

print(Cx, Cy, H)

Solution (Python):
n=int(input())
x,y,h=map(int,input().split())
d=set([(x,y,h)])
t=[x,y,h]
for i in range(n-1):
    x,y,h=map(int,input().split())
    d.add((x,y,h))
    if t[2]==0: t=[x,y,h]

for i in range(101):
    for j in range(101):
        f=0
        p=abs(t[0]-i)+abs(t[1]-j)+t[2]
        for k in d:
            if k[2]!=0 and abs(k[0]-i)+abs(k[1]-j)+k[2]!=p: f=1
            if k[2]==0 and abs(k[0]-i)+abs(k[1]-j)+k[2]<p: f=1
        if f==0:
            print(i,j,p)
            exit()

Solution (Python):
def main():
    n = int(input())

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

    l.sort(key = lambda x:-x[2])

    for cx in range(0, 101):
        for cy in range(0, 101):
            for i, xyh in enumerate(l):
                x,y,h = xyh
                if i == 0:
                    H = h + abs(x-cx) + abs(y-cy)
                    if H < 1 or H != int(H):
                        break
                    continue
                if h != max((H - abs(x-cx) - abs(y-cy)), 0):
                    break
                if i == n-1:
                    print(cx,cy,H)
                    return

if __name__ == "__main__":
    main()

Solution (Python):
N = int(input())
D = []
for i in range(N):
  D.append(list(map(int, input().split())))
D.sort(key = lambda x:x[2], reverse = True)
for i in range(101):
  for j in range(101):
    F = True
    H = abs(i - D[0][0]) + abs(j-D[0][1]) + D[0][2]
    for k in range(1,N):
      if D[k][2] != 0:
        if H != abs(i - D[k][0]) + abs(j-D[k][1]) + D[k][2]:
          F = False
          break
      else:
        if H > abs(i - D[k][0]) + abs(j-D[k][1]) + D[k][2]:
          F = False
          break
    if F == True:
      print(str(i) + " " + str(j) + " " + str(H))
      exit()

Solution (Python):
N = int(input())
xs = []
ys = []
hs = []
for i in range(N):
    x, y, h = map(int, input().split())
    xs.append(x)
    ys.append(y)
    hs.append(h)

for cx in range(100 + 1):
    for cy in range(100 + 1):
        flg = True
        for i in range(N):
            if hs[i] == 0:
                continue
            H = hs[i] + abs(xs[i] - cx)  + abs(ys[i] - cy)
            if H != 0:
                break
        if H == 0:
            break
        for i in range(N):
            h_ = max(H - abs(xs[i] - cx) - abs(ys[i] - cy), 0)
            if hs[i] != h_:
                flg = False
                break
        if flg:
            print("{0} {1} {2}".format(cx, cy, H))
            exit()

Solution (Python):
n = int(input())
data = [list(map(int, input().split())) for _ in range(n)]
for c_x in range(101):
    for c_y in range(101):
        valid = True
        H = None
        
        for i in range(n):
            x, y, h = data[i]
            if h >= 1:
                H = h + abs(x-c_x) + abs(y-c_y)
                break
        for i in range(n):
            x, y, h = data[i]
            if h != max(H - abs(x-c_x) - abs(y-c_y), 0):
                valid = False
                break
        if valid:
            print(c_x, c_y, H)

Solution (Python):

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

XYH = sorted(XYH, key=lambda x:x[2],reverse=True)

ans_xy = [(0,0)]
ans_H  = 0
for X in range(101):
    for Y in range(101):
        for i in range(N):
            x,y,h = XYH[i]

            if i == 0:
                H_q = h + abs(X-x) + abs(Y-y)
            else:
                h_now = max(0, H_q - abs(X-x) - abs(Y-y))
                if h_now != h:
                    break
        else:
            ans_H = H_q
            print(X,Y,ans_H)
            exit()

Solution (Python):
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]
        hp = ph + abs(i - px) + abs(j - py)
        if all([ph == max(hp - abs(i - px) - abs(j - py), 0) for ph, px, py in points]):
            print(i, j, hp)
            exit()

Solution (Python):
import sys
N = int(input())
point = [[int(i) for i in input().split()] for _ in range(N)]
point.sort(key=lambda x:x[2],reverse=True)
for cx in range(101):
    for cy in range(101):
        H = point[0][2]+abs(cx-point[0][0])+abs(cy-point[0][1])
        OK = True
        for i in range(N):
            if not point[i][2]==max(H-abs(cx-point[i][0])-abs(cy-point[i][1]),0):
                OK = False
                break
        if OK:
            print(cx,cy,H)
            sys.exit(0)

Solution (Python):
from math import *
import sys

N = int(input())
all_input_list = [list(map(int, input().split())) for i in range(N)]
x, y, h = sorted(all_input_list, key=lambda x: x[2])[-1]
for cx in range(101):
    for cy in range(101):
        H = h + abs(cx - x) + abs(cy - y)
        for input_list in all_input_list:
            if (input_list[2] != max(H - abs(cx - input_list[0]) - abs(cy - input_list[1]), 0)):
                break
        else:
            print("%s %s %s" % (cx, cy, H))
            sys.exit(0)

Solution (Python):
from math import *

N = int(input())
all_input_list = [list(map(int, input().split())) for i in range(N)]
x, y, h = [all_input_list[i] for i in range(N) if all_input_list[i][2] > 0][0]
for cx in range(101):
    for cy in range(101):
        H = h + abs(cx - x) + abs(cy - y)
        for input_list in all_input_list:
            if (input_list[2] != max(H - abs(cx - input_list[0]) - abs(cy - input_list[1]), 0)):
                break
        else:
            print("%s %s %s" % (cx, cy, H))
            exit()

Solution (Python):
from math import *

N = int(input())
all_input_list = [list(map(int, input().split())) for i in range(N)]
x, y, h = [all_input_list[i] for i in range(N) if all_input_list[i][2] > 0][0]
for cx in range(101):
    for cy in range(101):
        H = h + abs(cx - x) + abs(cy - y)
        
        for input_list in all_input_list:
            if (input_list[2] != max(H - abs(cx - input_list[0]) - abs(cy - input_list[1]), 0)):
                break
        else:
            print("%s %s %s" % (cx, cy, H))
            exit()

Solution (Python):
from math import *
import sys

N = int(input())
all_input_list = [list(map(int, input().split())) for i in range(N)]
x, y, h = [all_input_list[i] for i in range(N) if all_input_list[i][2] > 0][0]
for cx in range(101):
    for cy in range(101):
        H = h + abs(cx - x) + abs(cy - y)
        for xi, yi, hi in all_input_list:
            if (hi != max(H - abs(cx - xi) - abs(cy - yi), 0)):
                break
        else:
            print("%s %s %s" % (cx, cy, H))
            sys.exit(0)

Solution (Python):
from math import *
import sys

N = int(input())
all_input_list = [list(map(int, input().split())) for i in range(N)]
x, y, h = [all_input_list[i] for i in range(N) if all_input_list[i][2] > 0][0]
for cx in range(101):
    for cy in range(101):
        H = h + abs(cx - x) + abs(cy - y)
        for input_list in all_input_list:
            if (input_list[2] != max(H - abs(cx - input_list[0]) - abs(cy - input_list[1]), 0)):
                break
        else:
            print("%s %s %s" % (cx, cy, H))
            sys.exit(0)

Solution (Python):
from math import *
import sys

N = int(input())
all_input_list = [[int(j) for j in input().split()] for i in range(N)]
x, y, h = [all_input_list[i] for i in range(N) if all_input_list[i][2] > 0][0]
for cx in range(101):
    for cy in range(101):
        flag = 1
        H = h + abs(cx - x) + abs(cy - y)
        for input_list in all_input_list:
            if (input_list[2] != max(H - abs(cx - input_list[0]) - abs(cy - input_list[1]), 0)):
                flag = 0
                break
        if (flag == 1):
            print("%s %s %s" % (cx, cy, H))
            sys.exit(0)

Solution (Python):
from math import *
from itertools import *
import sys

N = int(input())
all_input_list = [list(map(int, input().split())) for i in range(N)]
x, y, h = [all_input_list[i] for i in range(N) if all_input_list[i][2] > 0][0]
for cx, cy in product(range(101), range(101)):
    flag = 1
    H = h + abs(cx - x) + abs(cy - y)
    for input_list in all_input_list:
        if (input_list[2] != max(H - abs(cx - input_list[0]) - abs(cy - input_list[1]), 0)):
            flag = 0
            break
    if (flag == 1):
        print("%s %s %s" % (cx, cy, H))
        sys.exit(0)

Solution (Python):
from math import *
import sys

N = int(input())
all_input_list = [list(map(int, input().split())) for i in range(N)]
x, y, h = [all_input_list[i] for i in range(N) if all_input_list[i][2] > 0][0]
for cx in range(101):
    for cy in range(101):
        flag = 1
        H = h + abs(cx - x) + abs(cy - y)
        for input_list in all_input_list:
            if (input_list[2] != max(H - abs(cx - input_list[0]) - abs(cy - input_list[1]), 0)):
                flag = 0
                break
        if (flag == 1):
            print("%s %s %s" % (cx, cy, H))
            sys.exit(0)

Solution (Python):
from math import *
import sys

N = int(input())
all_input_list = [list(map(int, input().split())) for i in range(N)]
x_y_h = [all_input_list[i] for i in range(N) if all_input_list[i][2] > 0][0]
for cx in range(101):
    for cy in range(101):
        flag = 1
        H = x_y_h[2] + abs(cx - x_y_h[0]) + abs(cy - x_y_h[1])
        for input_list in all_input_list:
            if (input_list[2] != max(H - abs(cx - input_list[0]) - abs(cy - input_list[1]), 0)):
                flag = 0
                break
        if (flag == 1):
            print("%s %s %s" % (cx, cy, H))
            sys.exit(0)