Problem:
 Score : 400 points    Problem Statement Takahashi has a water bottle with the shape of a rectangular prism whose base is a square of side a~\mathrm{cm} and whose height is b~\mathrm{cm} . (The thickness of the bottle can be ignored.)  We will pour x~\mathrm{cm}^3 of water into the bottle, and gradually tilt the bottle around one of the sides of the base.  When will the water be spilled? More formally, find the maximum angle in which we can tilt the bottle without spilling any water.      Constraints  All values in input are integers.  1 \leq a \leq 100  1 \leq b \leq 100  1 \leq x \leq a^2b         Input Input is given from Standard Input in the following format:  a  b  x       Output Print the maximum angle in which we can tilt the bottle without spilling any water, in degrees.
Your output will be judged as correct when the absolute or relative error from the judge's output is at most 10^{-6} .        Sample Input 1 2 2 4      Sample Output 1 45.0000000000  This bottle has a cubic shape, and it is half-full. The water gets spilled when we tilt the bottle more than 45 degrees.       Sample Input 2 12 21 10      Sample Output 2 89.7834636934  This bottle is almost empty. When the water gets spilled, the bottle is nearly horizontal.       Sample Input 3 3 1 8      Sample Output 3 4.2363947991  This bottle is almost full. When the water gets spilled, the bottle is still nearly vertical.

Solution (Python):
import math

a,b,x = list(map(int, input().strip().split()))
h = x/a/a
if h < b/2:
	aa = 2*x/a/b
	ans = math.atan2(aa, b) * 180 / math.pi
else:
	bb = 2*(a*a*b - x)/a/a
	ans = math.atan2(a, bb) * 180 / math.pi
print(90 - ans)

Solution (Python):
import math

a, b, x = map(int, input().split())

answer = 0

if (x / a ** 2) <= (b / 2):
    n = (2 * x) / (a * b)
    answer = math.degrees(math.atan(b / n))
elif (a ** 2 * b) == x:
    answer = 0
else:
    n = ((2 * x) / a ** 2) - b
    answer = 90 - math.degrees(math.atan(a / (b - n)))
print(answer)

Solution (Python):
import math

a, b, x = map(int,input().split())

answer = 0

if (x / a**2) <= (b/2):
  n = (2*x) / (a*b)
  answer = math.degrees(math.atan(b/n))
elif (a**2 * b) == x:
  answer = 0
else:
  n = ((2*x) / a**2) - b
  answer = 90 - math.degrees(math.atan(a / (b-n) ))

print(answer)

Solution (Python):
import math
a, b, x = map(int,input().split())
if x >= a*a*b/2:
    print(math.degrees(math.atan(2*(a*a*b-x)/(a**3))))
else:
    print(math.degrees(math.atan(a*b*b/(2*x))))

Solution (Python):

a,b,x=map(int,input().split())
import math
if a*a*b/2>x:
    ans=math.atan((a*b*b)/(2*x))
    print(180*ans/math.pi)
else:
    ans=math.atan(2*(a*a*b-x)/(a**3))
    print(180*ans/math.pi)

Solution (Python):
import math

a,b,x = map(int, input().split())

capacity = a * b

if x / a > capacity * 0.5:
    tan = 2 * (b / a - x / pow(a, 3)) 
    print(math.degrees(math.atan(tan)))
else:
    tan = 2 * x / (a * pow(b, 2))
    print(90 - math.degrees(math.atan(tan)))

Solution (Python):
import math
a, b, x = map(int, input().split())

side = x / a


if side <= a * b / 2:
    
    x = 2 * side / b
    rad = math.atan2(b, x)


else:
    y = (-2*side + 2* a*b)/a
    rad = math.atan2(y, a)


deg = math.degrees(rad)
print(deg)

Solution (Python):
a,b,x = map(int,input().split())

if (a*a*b/2)<=x:
    s = (2*a*a*b-2*x)/(a**3)
else:
    s = (a*b*b)/(2*x)

import math
theta = math.degrees(math.atan(s))

print(theta)

Solution (Python):
import math
a,b,x = map(int,input().split())

if x > b*a**2/2:
    y = 2*b - 2*x/(a**2)
    print(math.atan(y/a)*180/math.pi)
else:
    y = 2*x/(a*b)
    print(math.atan(b/y)*180/math.pi)

Solution (Python):
import numpy as np

a,b,x=map(int,input().split())
S=a**2*b-x

if a**2*b/2 <= x:
    z=S*2/(a**2)
    rad=np.arctan(z/a)
else:
    z=x*2/(a*b)
    rad=np.arctan(b/z)
print(np.rad2deg(rad))

Solution (Python):
import numpy as np

a,b,x=map(int,input().split())
S=a**2*b-x

if a**2*b/2 <= x:
    z=S*2/(a**2)
    rad=np.arctan(z/a)
else:
    z=x*2/(a*b)
    rad=np.arctan(b/z)
print(np.rad2deg(rad))

Solution (Python):
import math

a, b, x=map(int, input().split())
ans=math.degrees(math.atan(2*(a*a*b-x)/a**3) if x>=a**2*b/2 else math.atan(a*b**2/(2*x)))
print(ans)

Solution (Python):
import math

a,b,x=map(int,input().split())

if x<=(a**2)*b/2:
  y=x/a*2/b
  print(' {:.10f}'.format(math.atan(b/y)/math.pi*180))
else:
  z=b*2-2*x/(a**2)
  print(' {:.10f}'.format(math.atan(z/a)/math.pi*180))

Solution (Python):
import numpy as np

a,b,x=map(int,input().split())
S=a**2*b-x

if a**2*b/2 <= x:
    z=S*2/(a**2)
    rad=np.arctan(z/a)
else:
    z=x*2/(a*b)
    rad=np.arctan(b/z)
print(np.rad2deg(rad))

Solution (Python):
a,b,x = map(int,input().split())

import math
if (x/a < 0.5*a*b):
  print(90-math.degrees(math.atan((2*x)/(a*b**2))))
elif (x/a == a*b):
  print(0)
else:
  print(90-math.degrees(math.atan(0.5*a**3/((b*a**2)-x))))

Solution (Python):
import math
a, b, x = map(int, input().split())
def pta(a, b, sita):
    return  a * b - ((a ** 2) * math.tan(math.radians(sita)) / 2)
def ptb(a, b, sita):
    return (b ** 2 * math.tan(math.radians(90-sita)) / 2)
max = 90
min = 0
for i in range(60):
    sen = (max + min) / 2

    if (a ** 2) * b / 2 >= x:
        
        if ptb(a, b, sen) >= x / a:
            min = sen
        else:
            max = sen
    else:
        
        if pta(a, b, sen) >= x / a:
            min = sen
        else:
            max = sen

print(sen)

Solution (Python):
import numpy as np

a,b,x=map(int,input().split())
S=a**2*b-x

if a**2*b/2 <= x:
    z=S*2/(a**2)
    rad=np.arctan(z/a)
else:
    z=x*2/(a*b)
    rad=np.arctan(b/z)
print(np.rad2deg(rad))

Solution (Python):


import math


def main():
  a, b, x = map(int, input().split())
  x = x / a
  low = 0
  high = 90

  for _ in range(100):
    r = (low + high) * 0.5
    rb = math.tan(r * math.pi / 180) * a
    ra = math.tan((90 - r) * math.pi / 180) * b

    if rb < b:
      y = a * b - a * rb * 0.5
    else:
      y = ra * b * 0.5

    if y > x:
      low = r
    else:
      high = r

  print((low + high) * 0.5)


if __name__ == '__main__':
  main()

Solution (Python):
import math
a,b,x=map(int,input().split())
if x<=a*a*b/2:
    h=2*x/a/b
    print(math.degrees(math.atan(b/h)))
else:
    h=2*(a*a*b-x)/a/a
    print(math.degrees(math.atan(h/a)))

Solution (Python):
from math import atan2, degrees


def solve(string):
    a, b, x = map(int, string.split())
    if x >= a**2 * b / 2:
        c, d = 2 * (a**2 * b - x), a**3
    else:
        c, d = a * b**2, 2 * x
    return str(degrees(atan2(c, d)))


if __name__ == '__main__':
    print(solve(input()))

Solution (Python):
from math import atan2, pi


def solve(string):
    a, b, x = map(int, string.split())
    if x >= a**2 * b / 2:
        c, d = 2 * (a**2 * b - x), a**3
    else:
        c, d = a * b**2, 2 * x
    return str(atan2(c, d) * 180 / pi)


if __name__ == '__main__':
    print(solve(input()))

Solution (Python):
import math

a,b,volume=map(int,input().split())
V=a*a*b
space=V-volume
if space>volume:
  high=volume*2/a/b
  print(math.degrees(math.atan(b/high)))
elif space<=volume:
  high2=space*2/a/a
  print(math.degrees(math.atan(high2/a)))

Solution (Python):



import math

side, height, volume = [int(i) for i in input().split()]

fullvolume = side * side * height
space_height = (fullvolume - volume) / (side * side)

if volume*2 >= fullvolume:
    print(math.degrees(math.atan(space_height*2 / side)))
else:
    print(math.degrees(math.atan(height / (2*volume/side/height) )))

Solution (Python):
import math
a,b,x=map(int,input().split())

if x<(a*a*b/2):
    c=x*2/a/b
    print(math.degrees(math.atan(b/c)))

else:
    c=(a*a*b*2-x*2)/a/a
    print(math.degrees(math.atan(c/a)))

Solution (Python):
import numpy as np
import math

a,b,x = map(int,input().split())
taiseki = a*a*b
mizu_height = x / (a*a)
parcent = x/taiseki

if x/taiseki <= 0.5:
    menseki = mizu_height*a
    a = 2 * menseki / b
    
    teihen = np.sqrt(a**2+b**2)
    
    height = 2*menseki/teihen
    
    print(90-math.degrees(math.asin(height/b)))

else:
    menseki = mizu_height * a
    daikei_hen = 2*menseki/a - b

    sankaku_b = b - daikei_hen

    sankaku_menseki = a*sankaku_b/2
    daikei_menseki = menseki - sankaku_menseki

    sankaku_teihen = np.sqrt(a**2+sankaku_b**2)
    sankaku_height = 2*sankaku_menseki/sankaku_teihen

    daikei_height = daikei_menseki/sankaku_teihen

    height = daikei_height + sankaku_height

    print(90-math.degrees(math.asin(height/b)))

Solution (Python):
import math

a, b, x = map(int, input().split())

v = (a * a * b)/2

if x >= v:
  print(math.degrees(math.atan(2*(2*v-x)/(a**3))))
else:
  print(math.degrees(math.atan((a*b*b)/(2*x))))

Solution (Python):
import math
a,b,x=map(int,input().split())

if x<=a**2*b/2:
 c=2*x/a/b
 e=c/((b**2+c**2)**(0.5))
 d=math.acos(e)*180/math.pi
else:
 c=2*b-(2*x/a/a)
 e=c/((a**2+c**2)**(0.5))
 d=90-math.acos(e)*180/math.pi
print(d)

Solution (Python):
import math

a, b, x = map(int, input().split())

if a**2 * b / 2 < x:
    print(90-math.degrees(math.atan2(a**3, 2*(a**2 * b - x))))
else:
    print(90-math.degrees(math.atan2(2*x, a * b**2)))

Solution (Python):
import math

a, b, x = map(int, input().split())

if a**2 * b / 2 < x:
    print(90-math.degrees(math.atan2(a**3, 2*(a**2 * b - x))))
else:
    print(90-math.degrees(math.atan2(2*x, a * b**2)))

Solution (Python):
import math
a,b,x=map(int,input().split())
c1=a*a*b/2
if x==a*a*b:
    print(0.0)
    exit(0)
if x>c1:
    ans=math.atan((a*a*a)/((2*a*a*b)-(2*x)))
    ans=math.degrees(ans)
    print(90-ans)
else:
    ans=math.atan((2*x)/(a*b*b))
    ans=math.degrees(ans)
    print(90-ans)

Solution (Python):
import math
a,b,x = map(int,input().split())

if x < (a*a*b/2):
    tmp = 2*x/(b**2*a)
    ans = 90.0 - math.degrees(math.atan(tmp))
else:
    tmp = 2*b/a - 2*x/(a**3)
    ans = math.degrees(math.atan(tmp))
print(ans)

Solution (Python):
import math
pi=3.1415926535897932
chk=0.0000001
a,b,x=map(int,input().split())
t=a*b/2
s=x/a
if t>s:
    h=[0,a]
    while 1:
        hs=(h[0]+h[1])/2
        w=b*hs/2
        if abs(w-s)<chk:
            break
        elif w>s:
            h[1]=hs
        elif w<s:
            h[0]=hs
    print(90-math.atan(hs/b)*180/pi)
else:
    h=[0,b]
    while 1:
        hs=(h[0]+h[1])/2
        w=(hs+b)*a/2
        if abs(w-s)<chk:
            break
        elif w>s:
            h[1]=hs
        elif w<s:
            h[0]=hs
    print(90-math.atan(a/(b-hs))*180/pi)

Solution (Python):
import math


def main():
    s = input().split(" ")
    a = float(s[0])
    b = float(s[1])
    x = float(s[2])
    if(a * a * b / 2 < x):
        print(math.atan(2 * (a * a * b - x) / a / a / a) / math.pi * 180)
    else:
        print(math.atan(a * b * b / 2 / x) / math.pi * 180)


if(__name__ == "__main__"):
    main()

Solution (Python):
import numpy as np

a, b, x = map(int, input().split())
if(x >= 0.5*a*a*b):
  t_theta = (2*b)/a - (2*x)/a**3
  print ((180 * np.arctan(t_theta)) / np.pi)
else:
  t_theta = (a*b*b) / (2*x)
  print ((180 * np.arctan(t_theta)) / np.pi)

Solution (Python):
import math
a,b,x = map(int,input().split())

l = x / (a*a*b)
c = b*l
if (b == c):
    print(0)
    exit()
elif(c>=b/2):
    t = a/(b-c)/2
else:
    t = 2*a*c/b**2

print('{:.8f}'.format(90-math.degrees(math.atan(t))))

Solution (Python):
import math 
 
side, height, volume = list(map(int, input().split()))
 
fullvolume = side * side * height
space = fullvolume - volume
 
if fullvolume/2 > volume:
  n = (2 * volume) / (side * height)
  
  angle = 90 - math.degrees(math.atan(n/height))
else:
  n = (2 * space) / (side * side)
  angle = math.degrees(math.atan(n/side))
print(angle)

Solution (Python):
import math

def main():
    side,high,volume = list(map(int,input().split()))

    fullvolume = side * side * high
    space = fullvolume - volume

    if space < volume:
        prizm_high = space / (side * side / 2)
        angle = math.degrees(math.atan(prizm_high/side))
    else:
        prizm_high = volume / (high * side / 2)
        angle = 90 - math.degrees(math.atan(prizm_high/high))


    print(angle)

if __name__ == "__main__":
    main()

Solution (Python):
import math
a,b,x = map(int,input().split())
ans = 0
if (a*a*b)/2>=x :
    t = x*2/b/a/b
    ans = 90-math.degrees(math.atan(t))
elif (a*a*b)==x:
    ans = 0.0
else :
    x = (a*a*b) - x
    t = x*2/a/a
    ans = 90-math.degrees(math.atan(a/t))
print(ans)

Solution (Python):
import numpy as np

a,b,x = map(int,input().split())
if a*a*b > x*2:
    print(90-np.rad2deg(np.arctan(2*x/(a*b*b))))
else:
    print(np.rad2deg(np.arctan(2*(a*a*b-x)/(a**3))))

Solution (Python):
import math
from sys import exit
a,b,x = map(int, input().split())
j = x/a - a * b / 2
if j == 0:
    print(math.degrees(math.atan(b/a)))
elif j > 0:
    ans = (2*x/(a*a) - 2*b) / (-a)
    print(math.degrees(math.atan(ans)))
else:
    print(math.degrees(math.atan(a*b*b/(2*x))))

Solution (Python):
import math
a,b,x=map(int,input().split(" "))
if x>a**2*b/2:
    V=a**2*b-x
    L=2*V/(a**2)
    print(math.degrees(math.atan(L/a)))
else:
    L=2*x/(a*b)
    print(math.degrees(math.atan(b/L)))

Solution (Python):
import math
import sys
sys.setrecursionlimit(10**7)
INTMAX = 9223372036854775807
INTMIN = -9223372036854775808
MOD = 1000000007
def POW(x, y): return pow(x, y, MOD)
def INV(x, m=MOD): return pow(x, m - 2, m)
def DIV(x, y, m=MOD): return (x * INV(y, m)) % m
def LI(): return [int(x) for x in input().split()]
def LF(): return [float(x) for x in input().split()]
def LS(): return input().split()
def II(): return int(input())

a,b,x=LI()

FUL=a*a*b

if x >= FUL*0.5:
    rest = FUL-x
    
    h = rest / a / a * 2
    print((math.atan(h/a) / (2*math.pi))*360)
else:
    h = x / a / b * 2
    res = 90 - (math.atan(h / b) / (2*math.pi) * 360)
    print(res)

Solution (Python):
import math

a, b, x = map(int, input().split())
s = x / a

aa = (2 * x) / (a * b)
if aa <= a:
	theta = math.atan2(b,aa)
else:
	
	
	
	
	bb = (a * b - s) * 2 / a
	theta = math.atan2(bb,a)
print(math.degrees(theta))

Solution (Python):
import math
a, b, x = map(int, input().split())

lim = a * b * (1/2) * a

if x > lim:
  tan_c = 2 *(b - x/(a**2)) / a
  ans = math.atan(tan_c)
else:
  tan_c = a * (b ** 2) / (2 * x)
  ans = math.atan(tan_c)
  
print(math.degrees(ans))

Solution (Python):
import math
a, b, x = map(float, input().split())
if x < a * a * b / 2:
    print(math.atan(a * b * b / (2 * x)) * 180 / math.pi)
else:
    print(math.atan((b - x / (a * a)) * 2 / a) * 180 / math.pi)

Solution (Python):
import math
a, b, x = map(int, input().split())

if a*a*b/2 < x:
    degree = math.degrees(math.atan((2*(a*a*b-x)/a**3)))
    print(degree)
else:
    print(math.degrees(math.atan(a*b*b/2/x)))

Solution (Python):
import math
a, b, x = map(int, input().split())

if a*a*b/2 < x:
    degree = math.degrees(math.atan((2*(a*a*b-x)/a**3)))
    print(degree)
else:
    print(math.degrees(math.atan(a*b*b/2/x)))

Solution (Python):
from math import tan, pi
a,b,x = map(int, input().split())
eps = 1e-6

def f(a,b,t):
  if pi/2-t<eps: return 0
  if b*tan(pi/2.-t) < a: return b*b*tan(pi/2.-t)/2.*a
  else: return a*a*b - a*a*tan(t)/2.*a
  
th_p, th_n = pi/2, 0.
for i in range(100000):
  th_m = (th_p + th_n)/2.
  err = f(a,b,th_m) - x
  if err**2 < eps**2: break
  elif err < 0: th_p = th_m
  else: th_n = th_m
print(180/pi*th_m)

Solution (Python):
import math

a,b,x = map(int, input().split())
c = a * b
if c / 2 >= x / a:
  ans = math.degrees(math.atan((a*b**2)/(2*x)))
else:
  ans = math.degrees(math.atan((a*b-x/a)*(2/a**2)))
print(ans)

Solution (Python):
import math

a,b,x=map(int,input().split())
S=x/a

if S <= a*b/2:
    ans = math.atan((b**2)/(2*S))
else:
    S = a*b - S
    ans = math.atan(S*2/(a**2))

ans = ans * 180/math.pi
print(ans)

Solution (Python):
import math

a, b, x = map(int, input().split())
y = 2*b - 2*x/a**2
if y <= b:
    ans = math.degrees(math.atan(y/a))
    print(ans)
else:
    yy = 2*x/(a*b)
    ans = math.degrees(math.atan(b/yy))
    print(ans)

Solution (Python):
import math
a,b,x=map(int,input().split())
if x>=(b*(a**2))/2:
    print(math.degrees(math.atan(2*(b/a-x/a**3))))
else:
    print(math.degrees(math.atan((a*(b**2))/(2*x))))

Solution (Python):
import math

a,b,x = map(int, input().split())
m = a*a*b
z = math.degrees(math.atan(b / a))

if x >= m / 2:  
  z = ((x*2) / (a*a)) - b
  r = math.degrees(math.atan((b - z) / a))
  print(r)
else:  
  z = (x*2) / (a*b)
  r = 90 - math.degrees(math.atan(z / b))
  print(r)

Solution (Python):
import math
a,b,x = [int(x) for x in input().split()]
c = 2*b/a - 2*x/a**3
if c > b/a:
  print(math.degrees(math.atan(a*b**2/(2*x))))
else:
  print(math.degrees(math.atan(c)))

Solution (Python):
import math
a,b,x = [int(x) for x in input().split()]
c = 2*b/a - 2*x/a**3
if c > 2*x/a**3:
  print(math.degrees(math.atan(a*b**2/(2*x))))
else:
  print(math.degrees(math.atan(c)))

Solution (Python):
import math
a,b,x=map(int,input().split())
c=(2*x-b*(a**2))/a**2
ans=0
if c>=0:
    ans=90-math.degrees(math.atan2(a,b-c))
else:
    d=2*x/(a*b**2)
    ans=90-math.degrees(math.atan2(2*x,a*b**2))
print(ans)

Solution (Python):


import sys
from math import degrees, radians, sin, cos

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

def bisearch_max(mn, mx, func):
    """ 条件を満たす最大値を見つける二分探索(小数用) """

    ok = mn
    ng = mx
    for _ in range(100):
        mid = (ok+ng) / 2
        if func(mid):
            
            ok = mid
        else:
            
            ng = mid
    return ok


def calc1(dig1):
    
    dig2 = 90 - dig1
    if dig2 == 0:
        return False
    
    h = b * sin(radians(dig2))
    
    c = b / cos(radians(dig2))
    
    limit = h * c / 2
    return S <= limit

def calc2(dig1):
    
    h = a * sin(radians(dig1))
    
    c = a / cos(radians(dig1))
    
    limit = a * b - h * c / 2
    return S <= limit

a, b, x = MAP()


S = x / a

if S <= a * b / 2:
    calc = calc1
else:
    calc = calc2
dig = bisearch_max(0, 90, calc)
print(dig)

Solution (Python):

a,b,x = list(map(int,input().split()))
from math import atan2,degrees
w = x/a
if w > a * b / 2:
    print(degrees(atan2(2*b - 2*x/a/a,a)))
else:
    print(degrees(atan2(b,2*x/a/b)))

Solution (Python):


import sys
from math import degrees, radians, sin, cos

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

def bisearch_max(mn, mx, func):
    """ 条件を満たす最大値を見つける二分探索(小数用) """

    ok = mn
    ng = mx
    for _ in range(100):
        mid = (ok+ng) / 2
        if func(mid):
            
            ok = mid
        else:
            
            ng = mid
    return ok

a, b, x = MAP()

h = b * (x / (a * a * b))
S = a * h


def calc(dig1):
    
    h1 = a * sin(radians(dig1))
    
    dig2 = 90 - dig1
    if dig2 == 0:
        return False
    
    h2 = b * sin(radians(dig2))
    
    if h2 >= h1:
        
        d = a / cos(radians(dig1))
        
        S1 = d * h1 / 2
        
        if S1 >= S:
            return True
        
        S2 = S - S1
        
        h3 = S2 / d
        
        return h1 + h3 <= h2
    
    else:
        
        e1 = b / cos(radians(dig2))
        
        e2 = S / h2 * 2
        return e2 <= e1

dig = bisearch_max(0, 90, calc)
print(dig)

Solution (Python):
from math import *
a, b, x = [float(a) for a in input().split()]
if x / a < a * b / 2:
    ans = atan2(a*b*b, 2*x)
else:
    ans = atan2(2*(a*a*b-x), a**3)

print(ans * 180 / pi)

Solution (Python):
import math

a,b,x = map(int,input().split())
if x > (b*(a**2))/2:
    c = (2*(((a**2)*b)-x))/(a**3)
    ans = math.degrees(math.atan(c))
else:
    d = (a*(b**2))/(x*2)
    ans = math.degrees(math.atan(d))
print(ans)

Solution (Python):
import math
a, b, x = map(int, input().split())
h = x/a**2

if b == h:
    print(0)
    exit()
elif h >= b/2:
    tanth = a / (b - h) / 2
else:
    tanth = 2 * a * h / b**2

theta = math.degrees(math.atan(tanth))
print(90 - theta)

Solution (Python):
import math
a, b, x = map(int, input().split())
s = x / a
rad = 0
if s >= a*b / 2:
    h = (a*b-s)*2/a
    rad = math.atan2(h, a)
else:
    w = s*2 / b
    rad = math.atan2(b, w)
deg = rad / (2*math.pi)*360
print('{:.10f}'.format(deg))

Solution (Python):
from math import*
a,b,x=map(int,input().split())
print(atan(a*b*b/2/x*(x<a*a*b/2)or(b/a-x/a**3)*2)/pi*180)

Solution (Python):
import math
pi=3.1415926535897932
chk=0.0000001
a,b,x=map(int,input().split())
t=a*b/2
s=x/a
if abs(t-s)<chk:
    print(45.0)
elif t>s:
    h=[0,a]
    while 1:
        hs=(h[0]+h[1])/2
        w=b*hs/2
        if abs(w-s)<chk:
            break
        elif w>s:
            h[1]=hs
        elif w<s:
            h[0]=hs
    print(90-math.atan(hs/b)*180/pi)
else:
    h=[0,b]
    while 1:
        hs=(h[0]+h[1])/2
        w=(hs+b)*a/2
        if abs(w-s)<chk:
            break
        elif w>s:
            h[1]=hs
        elif w<s:
            h[0]=hs
    print(90-math.atan(a/(b-hs))*180/pi)

Solution (Python):
from math import*
a,b,x=map(int,input().split())
print(atan(2*(b/a-x/a**3)if x>a*a*b/2else a*b*b/2/x)/pi*180)

Solution (Python):
from math import*
a,b,x=map(int,input().split())
print(atan(2*(b/a-x/a**3)if x>a**2*b/2else a*b**2/2/x)/pi*180)

Solution (Python):
from math import*
a,b,x=map(int,input().split())
print(atan(2*(b/a-x/a**3)if x>a**2*b/2else a*b**2/(2*x))/pi*180)

Solution (Python):
import math
a, b, x  = map(int, input().split())
boxv = a**2*b
if boxv /2 <= x:
    print(math.degrees(math.atan((2*(boxv - x ))/a**3)))
else:
    print(math.degrees(math.atan((a*b**2)/(2 * x))))

Solution (Python):
import math
a, b, x = map(int, input().split())
h = x/a**2

if b == h:
    print(0)
elif h >= b/2:
    tanth = a / (b - h) / 2
    theta = math.degrees(math.atan(tanth))
    print(90 - theta)
else:
    tanth = 2 * a * h / b**2
    theta = math.degrees(math.atan(tanth))
    print(90 - theta)

Solution (Python):
import math
PI=3.14159265358979323846
a,b,x=map(int,input().split())
s=x/a
ans=0
a2=0

if s==a*b:
  ans=0
else:
  if s>b*a/2:
    bu=2*s/a-b
    s-=a*bu
    b-=bu
    a2=2*s/b
  else:
    a2=2*s/b
  r=math.atan(b/a2)
  ans=r*(180/PI)
print(ans)

Solution (Python):
import math
a,b,x = map(float,input().split())

c = (2*b-(2*x)/(a*a))/a
d = (a*b*b)/(2*x)
if x/a >= a*b/2:
  result = math.degrees(math.atan(c))
else:
  result = math.degrees(math.atan(d))
print(result)

Solution (Python):
a, b, x = map(int, input().split())

from math import atan
from math import degrees

if x >= 0.5 * a * a * b:
  theta = atan(2*(a*a*b - x) / (a**3))
else:
  theta = atan(0.5 * a * b* b / x)
print(degrees(theta))

Solution (Python):
import sys
import os
import math
a,b,x = map(int,input().split())
if x >= (a**2)*b/2:
    ｙ = 2*(a*a*b-x)/(a*a)
    print((math.degrees(math.atan2(y,a))))
else:
    y = 2*x/(a*b)
    print((math.degrees(math.atan2(b,y))))

Solution (Python):
import math
a,b,x=map(int,input().split())
if(b*(a**2)/2<x):
    ans=math.atan(2*b/a-2*x/(a**3))
else:
    ans=math.atan(a*(b**2)/(2*x))
print(math.degrees(ans))

Solution (Python):
from math import atan2, degrees

a, b, x = map(int, input().split())


c = 2 * x / (a * b)


d = 2 * x / (a * a) - b

if c <= a:
    deg = 90 - degrees(atan2(c, b))
else:
    deg = degrees(atan2(b - d, a))

print(deg)

Solution (Python):
from math import degrees, atan
a, b, x = map(float, input().split())
y = min(x, a * a * b - x)
if y != x:
  print(degrees(atan(2 * y / a / a / a)))
else:
  print(90 - degrees(atan(2 * y / a / b / b)))

Solution (Python):
import math
a,b,x = map(int,input().split())
v = a**2*b
d = 0
if x<v/2:
  d = math.atan2(b,x*2/a/b)
else:
  d = math.atan2((v-x)*2/a/a,a)
print(math.degrees(d))

Solution (Python):
import math

a,b,x=map(int,input().split())
h= x/a**2

if b < 2 * h:
  print(math.atan(2*(b-h)/a) / math.pi * 180)
else:
  print((math.pi/2 - math.atan(2*x/a/b**2)) / math.pi * 180)

Solution (Python):
import math

a, b, x = map(int, input().split())

tan_theta = 2*(b/a-x/math.pow(a, 3))
tan_theta2 = a * pow(b, 2) / (2 * x)

if math.pow(a, 3) / 2 * tan_theta < x:
    theta = math.atan(tan_theta)
else:
    theta = math.atan(tan_theta2)

print(math.degrees(theta))

Solution (Python):
import math
a,b,x = map(int,input().split(" "))
v = a*a*b
if v >= 2*x:
    print(180*math.atan(a*b*b/(2*x))/math.pi)
else:
    print(180*math.atan((2*b/a)-(2*x/a/a/a))/math.pi)

Solution (Python):
import math
a,b,x = map(int,input().split())
if b*a**2 == x:
    print("0")
elif x >= (b*a**2)/2:
    print(90-math.degrees(math.atan(a**3/(2*(b*a**2-x)))))
else:
    print(90-math.degrees(math.atan(2*x/(a*b**2))))

Solution (Python):
import math

a,b,x = map(int,input().split())
if x > (a**2 * b)/2:
    print(math.degrees(float(math.atan(2*(a**2 * b-x)/a**3))))
else:
    print(90-math.degrees(float(math.atan(2*x/(a*b**2)))))

Solution (Python):
import numpy as np
a, b, x = map(int, input().split())
if a ** 2 * b / 2 >= x:
    print(np.rad2deg(np.arctan(a * b ** 2 / (2 * x))))
else:
    print(-np.rad2deg(np.arctan((2/a**3) * (x - (a ** 2) * b))))

Solution (Python):
import math
a,b,x = map(int,input().split())
menseki = x/a
takasa = menseki * 2 / b
if takasa <= a:
    print(90-(math.atan(takasa/b)*180/math.pi))
else:
    nokori = 2*b-(menseki * 2 / a)
    print(math.atan(nokori/a)*180/math.pi)

Solution (Python):


import sys
from math import atan2, degrees, radians, sqrt, sin, cos

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

def bisearch_max(mn, mx, func):
    """ 条件を満たす最大値を見つける二分探索(小数用) """

    ok = mn
    ng = mx
    for _ in range(100):
        mid = (ok+ng) / 2
        if func(mid):
            
            ok = mid
        else:
            
            ng = mid
    return ok

a, b, x = MAP()

h = b * (x / (a * a * b))
S = a * h


def calc(h1):
    
    c = sqrt(a**2 - h1**2)
    
    dig1 = degrees(atan2(h1, c))
    
    dig2 = 90 - dig1
    if dig2 == 0:
        return False
    
    h2 = b * sin(radians(dig2))
    
    if h2 >= h1:
        
        d = a / cos(radians(dig1))
        
        S1 = d * h1 / 2
        
        if S1 >= S:
            return True
        
        S2 = S - S1
        
        h3 = S2 / d
        
        return h1 + h3 <= h2
    
    else:
        
        e1 = b / cos(radians(dig2))
        
        e2 = S / h2 * 2
        return e2 <= e1

h = bisearch_max(0, a, calc)
w = sqrt(a**2 - h**2)
print(degrees(atan2(h, w)))

Solution (Python):
import math
a,b,x = map(int,input().split())

s = x / a
height = s / a

if height * 2 > b:
  print(math.degrees(math.atan((b-height)/(a*0.5))))

else:
  tall = s*2/b
  print(math.degrees(math.atan(b/tall)))

Solution (Python):
import math
a,b,x = map(int,input().split())
h = x/a/a
area = h*a
aa = area*2/b
tan = b/aa
deg = math.degrees(math.atan(tan))

area2 = a*b-area
bbb =area2*2/a
tan2 = bbb/a
deg2 = math.degrees(math.atan(tan2))

deg_s = math.degrees(math.atan(b/a))

if deg<deg_s and deg2<deg_s:
  print(min((deg,deg2)))
elif deg>=deg_s:
  print(deg)
else:
  print(deg2)

Solution (Python):

import math

a,b,x=map(int,input().split())
r=(pow(a,2)*b-(2*x))/(a*b)
pi=math.pi

if r>=0:
    ans=math.atan2(b,a-r)
else:
    t=2*(b-(x/pow(a,2)))
    ans=math.atan2(t,a)

print(math.degrees(ans))

Solution (Python):
from math import atan
from math import degrees
a,b,x=tuple(map(int,input().split()))
v=(a**2)*b
if 2*x>=v:
  h=x/(a**2)
  print(degrees(atan(2*(b-h)/a)))
else:
  print(degrees(atan(a*(b**2)/(x*2))))

Solution (Python):
from math import atan, pi
 
a, b, x = [float(x) for x in input().split()]
 
v = a * a * b
 
if v / 2 < x:
    t = atan(2 * (v - x) / (a * a * a))
else:
    
    t = pi / 2 - atan(2 * x / (a * b * b))
 
print(t * 180.0 / pi)

Solution (Python):
import math
a,b,x = map(int,input().split())
if a**2*b/2 <= x:
	atant = 2*(b/a-x/a**3)
	print(math.degrees(math.atan(atant)))
else:
	atant = a*b**2/(2*x)
	print(math.degrees(math.atan(atant)))

Solution (Python):
import math

a,b,x=map(int,input().split())

if a**2*b*0.5 >= x:
    h=x/a/b*2
    print(math.degrees(math.pi/2-math.atan(h/b)))
else:
    h=(a**2*b-x)/a/a*2
    print(math.degrees(math.atan(h/a)))

Solution (Python):
import math
a, b, x = map(int,input().split())
V = (a**2)*b
v = V*0.5
if x >= v:
    U = V - x
    c = (U*2) / (a**3)
    z = math.atan(c)
    print(math.degrees(z))
else:
    c = (a*(b**2)) / (x*2)
    z = math.atan(c)
    print(math.degrees(z))

Solution (Python):
import math



a,b,x = map(int, input().split(" "))



if x < a**2 * b * 0.5:

    rad = math.atan2(b, (2*x)/(a*b))

    dig = rad / math.pi * 180

    print(dig)


else:
    
    rad = math.atan2(a, (2*(a*a*b - x))/(a*a))

    dig = 90 - rad / math.pi * 180

    print(dig)

Solution (Python):
import math

a, b, x = [int(x) for x in input().split()]

bootle_volume = a * a * b
half_bootle_volume = 0.5 * bootle_volume

res = 0
if half_bootle_volume == x:
    res = math.degrees(math.atan(1))
elif half_bootle_volume > x:
    y = a - ((2 * x) / (a * b))
    degree = math.degrees(math.atan((a - y) / b))
    res = 90 - degree
elif half_bootle_volume < x:
    y = ((2 * x) / (a ** 2)) - b
    if y == b:
        res = 0
    else:
        degree = math.degrees(math.atan(a / (b - y)))
        res = 90 - degree

print(res)

Solution (Python):
import math
a,b,x = map(int,input().split())
volume = a*a*b

thita = 0
if x*2 >= volume:
    thita = math.atan((2/(a*a*a))*(volume-x))
else:
    thita = math.atan((a*b*b)/(2*x))
print(math.degrees(thita))

Solution (Python):

from math import atan, degrees


def main():
    A, B, X = map(int, input().split())
    if A ** 2 * B >= 2 * X:
        C = 2 * X / (A * B)
        ans = degrees(atan(B / C))
    else:
        C = 2 * (B - (X / A ** 2))
        ans = degrees(atan(C / A))
    print(ans)


if __name__ == "__main__":
    main()

Solution (Python):
import math

a, b, x = map(int, input().split())

s = x / a

if s == a * b:
    print(0)
else:
    if s > b * a / 2:
        bu = 2 * s / a - b
        s -= a * bu
        b -= bu
        a2 = 2 * s / b
    else:
        a2 = 2 * s / b

    rad = math.atan(b/a2)
    print(rad*(180/math.pi))