Problem:
Anchored Balloon A balloon placed on the ground is connected to one or more anchors on the ground with ropes.
Each rope is long enough to connect the balloon and the anchor.
No two ropes cross each other.
Figure E-1 shows such a situation.   Figure E-1: A balloon and ropes on the ground Now the balloon takes off, and your task is to find how high 
the balloon can go up with keeping the rope connections.
The positions of the anchors are fixed.
The lengths of the ropes and the positions of the anchors are given.
You may assume that these ropes have no weight and
thus can be straightened up when pulled to
whichever directions.
Figure E-2 shows the highest position of the balloon for
the situation shown in Figure E-1.   Figure E-2: The highest position of the balloon Input The input consists of multiple datasets, each in the following format.  n  x 1  y 1  l 1  ...  x n  y n  l n   The first line of a dataset contains an integer n (1 ≤ n ≤ 10) representing the number of the ropes.
Each of the following n lines contains three integers, x i , y i , and l i , separated by a single space. P i = 
( x i , y i ) represents
the position of the anchor connecting the i -th rope,
and l i represents the length of the rope.
You can assume that 
−100 ≤ x i ≤ 100, 
−100 ≤ y i ≤ 100, and
1 ≤ l i ≤ 300.
The balloon is initially placed at (0, 0) on the ground.
You can ignore the size of the balloon and the anchors. You can assume that P i and P j represent different positions if i ≠ j .
You can also assume that the distance between P i and (0, 0) is less than or equal to l i −1.
This means that the balloon can go up at least 1 unit high. Figures E-1 and E-2 correspond to the first dataset of Sample Input below. The end of the input is indicated by a line containing a zero. Output For each dataset, 
output a single line containing the maximum height that the balloon can go up.
The error of the value should be no greater than 0.00001. 
No extra characters should appear in the output. Sample Input 3
10 10 20
10 -10 20
-10 10 120
1
10 10 16
2
10 10 20
10 -10 20
2
100 0 101
-90 0 91
2
0 0 53
30 40 102
3
10 10 20
10 -10 20
-10 -10 20
3
1 5 13
5 -3 13
-3 -3 13
3
98 97 168
-82 -80 193
-99 -96 211
4
90 -100 160
-80 -80 150
90 80 150
80 80 245
4
85 -90 290
-80 -80 220
-85 90 145
85 90 170
5
0 0 4
3 0 5
-3 0 5
0 3 5
0 -3 5
10
95 -93 260
-86 96 211
91 90 177
-81 -80 124
-91 91 144
97 94 165
-90 -86 194
89 85 167
-93 -80 222
92 -84 218
0 Output for the Sample Input 17.3205081
16.0000000
17.3205081
13.8011200
53.0000000
14.1421356
12.0000000
128.3928757
94.1879092
131.1240816
4.0000000
72.2251798

Solution (Python):


import os
import sys
import math

def solve(f):
    n = f.read_int()
    if n == 0: raise StopIteration
    ary = [f.read_float_list() for _ in xrange(n)]

    x_min = -100.0
    x_max = 100.0

    for _ in xrange(60):
        c1 = (x_min*2 + x_max) / 3
        c2 = (x_min + x_max*2) / 3
        if search_y(ary, c1) > search_y(ary, c2):
            x_max = c2
        else:
            x_min = c1

    return math.sqrt(search_y(ary, x_max))

def search_y(ary, x):
    y_min = -100.0
    y_max = 100.0

    for _ in xrange(60):
        c1 = (y_min*2 + y_max) / 3
        c2 = (y_min + y_max*2) / 3
        if calc(ary, x, c1) > calc(ary, x, c2):
            y_max = c2
        else:
            y_min = c1

    return calc(ary, x, y_max)

def calc(ary, x, y):
    return min([item[2]**2 - (item[0]-x)**2 - (item[1]-y)**2 for item in ary])


class Reader(object):
    def __init__(self, filename=None):
        self.test_mode = filename is not None
        self.cases = 1
        self.buffer = []
        if self.test_mode:
            with open(filename) as f:
                blank_flg = False
                for line in f:
                    line = line.strip()
                    if line:
                        self.buffer.append(line)
                        blank_flg = False
                    else:
                        if not blank_flg: self.cases += 1
                        blank_flg = True

    def __readline(self):
        return self.buffer.pop(0) if self.test_mode else raw_input()

    def read_int(self):
        return int(self.__readline())
    def read_float(self):
        return float(self.__readline())
    def read_long(self):
        return long(self.__readline())
    def read_str(self):
        return self.__readline()

    def read_int_list(self):
        return [int(item) for item in self.__readline().split()]
    def read_float_list(self):
        return [float(item) for item in self.__readline().split()]
    def read_long_list(self):
        return [long(item) for item in self.__readline().split()]
    def read_str_list(self):
        return self.__readline().split()

if __name__ == '__main__':
    filename = sys.argv[1] if len(sys.argv)>1 else None
    f = Reader(filename)
    while True:
        try:
            print solve(f)
        except StopIteration:
            break

Solution (Python):
from math import sqrt
def calc(x1, y1, rr1, x2, y2, rr2):
    rr0 = (x2 - x1)**2 + (y2 - y1)**2
    xd = x2 - x1
    yd = y2 - y1
    cv = (rr0 + rr1 - rr2)
    if 4*rr0*rr1 < cv**2:
        return tuple()
    if 4*rr0*rr1 == cv**2:
        return ((x1 + cv*xd/(2.*rr0), y1 + cv*yd/(2.*rr0)),)
    sv = sqrt(4*rr0*rr1 - cv**2)
    return (
        (x1 + (cv*xd - sv*yd)/(2.*rr0), y1 + (cv*yd + sv*xd)/(2.*rr0)),
        (x1 + (cv*xd + sv*yd)/(2.*rr0), y1 + (cv*yd - sv*xd)/(2.*rr0)),
    )

def solve(mid):
    ps = []
    for i in xrange(n):
        x1, y1, l1 = P[i]
        if l1 < mid:
            return 0
        rr1 = l1**2 - mid**2
        for j in xrange(i):
            x2, y2, l2 = P[j]
            rr2 = l2**2 - mid**2
            if (x1 - x2)**2 + (y1 - y2)**2 > (sqrt(rr1)+sqrt(rr2))**2:
                return 0
            ps.extend(calc(x1, y1, rr1, x2, y2, rr2))
        ps.append((x1, y1))
    if n == 1:
        return 1
    for px, py in ps:
        if all((px-x)**2 + (py-y)**2 < l**2 - mid**2 + 1e-8 for x, y, l in P):
            return 1
    return 0

while 1:
    n = input()
    if n == 0:
        break
    P = [map(int, raw_input().split()) for i in xrange(n)]

    left = 1.; right = min(l for x, y, l in P)+1e-8
    while left+1e-8 < right:
        mid = (left + right) / 2.
        if solve(mid):
            left = mid
        else:
            right = mid
    print "%.08f" % left

Solution (Python):
"""http://mayokoex.hatenablog.com/entry/2015/06/11/124120を参照しました"""
"""三分探索、賢い"""
import sys
MI = 1e-6
def calc(x,y,b):
    res = 90000
    for bx,by,l in b:
        d = l**2-(x-bx)**2-(y-by)**2
        if d < res:
            res = d
    return res

def search_y(x,b):
    p = [-100,-33,33,100]
    for t in range(100):
        if abs(p[0]-p[3]) < MI:
            return (calc(x,p[0],b)+calc(x,p[3],b))/2
        l = calc(x,p[1],b)
        r = calc(x,p[2],b)
        if l < r:
            p[0] = p[1]
        else:
            p[3] = p[2]
        p[1] = (2*p[0]+p[3])/3
        p[2] = (p[0]+2*p[3])/3
    return (calc(x,p[0],b)+calc(x,p[3],b))/2

def search(b):
    p = [-100,-33,33,100]
    for t in range(100):
        if abs(p[0]-p[3]) < MI:
            return (search_y(p[0],b)+search_y(p[3],b))/2
        l = search_y(p[1],b)
        r = search_y(p[2],b)
        if l < r:
            p[0] = p[1]
        else:
            p[3] = p[2]
        p[1] = (2*p[0]+p[3])/3
        p[2] = (p[0]+2*p[3])/3
    return (search_y(p[0],b)+search_y(p[3],b))/2

def solve(n):
    b = [[int(x) for x in sys.stdin.readline().split()] for i in range(n)]
    ans = 0
    print(search(b)**0.5)

while 1:
    n = int(sys.stdin.readline())
    if n == 0:
        break
    solve(n)

Solution (Python):
import math,string,itertools,fractions,heapq,collections,re,array,bisect,sys,random,time,copy,functools

sys.setrecursionlimit(10**7)
inf = 10**20
eps = 1.0 / 10**13
mod = 10**9+7
dd = [(-1,0),(0,1),(1,0),(0,-1)]
ddn = [(-1,0),(-1,1),(0,1),(1,1),(1,0),(1,-1),(0,-1),(-1,-1)]

def LI(): return [int(x) for x in sys.stdin.readline().split()]
def LI_(): return [int(x)-1 for x in sys.stdin.readline().split()]
def LF(): return [float(x) for x in sys.stdin.readline().split()]
def LS(): return sys.stdin.readline().split()
def I(): return int(sys.stdin.readline())
def F(): return float(sys.stdin.readline())
def S(): return input()
def pf(s): return print(s, flush=True)

eps = 1e-7
def bs(f, mi, ma):
    mm = -1
    while ma > mi + eps:
        m1 = (mi*2+ma) / 3.0
        m2 = (mi+ma*2) / 3.0
        r1 = f(m1)
        r2 = f(m2)
        if r1 < r2:
            mi = m1
        else:
            ma = m2
    return f((ma+mi)/2.0)

def main():
    rr = []

    def f(n):
        a = [LI() for _ in range(n)]
        def _f(x,y):
            r = inf
            for px,py,l in a:
                r = min(r, l**2 - (x-px)**2 - (y-py)**2)
            return r
        def _fy(y):
            def _ff(x):
                return _f(x,y)
            return bs(_ff, -100, 100)
        r = bs(_fy,-100,100)

        return "{:0.7f}".format(r**0.5)

    while 1:
        n = I()
        if n == 0:
            break
        rr.append(f(n))

    return '\n'.join(map(str,rr))


print(main())