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.



Sample input:
2 2 4


Sample output:
45.0000000000

Submission status: Wrong Answer

Solution code:
# -*- coding: utf-8 -*-
import math
a, b, x = map(int,input().split())

ans = math.degrees(math.atan((a*b*b)/(2*x)))

print(ans)

Submission status: Wrong Answer

Solution code:
a, b, x = map(int, input().split())
lim = a ** 2 * b / 2
import math
theta = 0
if x >= lim:
    y = 2 * x / a ** 2 - b
    theta = math.atan((b - y)/a)
else:
    theta = math.atan(lim / x)
print(math.degrees(theta))

Submission status: Wrong Answer

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

h = x / (a * a) #height


if h > b / 2:
  sin = a / (a * math.sqrt(4 * (b - x) * (b - x) + a * a))
  print(math.degrees(math.asin(sin)))
elif h == b / 2:
  print(45.0000000000)
else:
  sin = a * x /(math.sqrt(4 * a * a * x * x + b * b))
  print(math.degrees(math.asin(sin)))

Submission status: Wrong Answer

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

Submission status: Wrong Answer

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

Submission status: Wrong Answer

Solution code:
import math
a, b, x = map(int, input().split())
if ((a**2) * b) / 2 - x < 10**(-5):
    print(45)
elif ((a**2) * b) / 2 < x:
    atan = math.degrees(math.atan((a**3)/(2*b*(a**2) - 2*x)))
    print(90-atan)
else:
    atan = math.degrees(math.atan((2*x)/(a*(b**2))))
    print(90-atan)

Submission status: Wrong Answer

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

Submission status: Wrong Answer

Solution code:
import math
a, b, x = map(int, input().split())
if x <= (a*a*b)/2:
    n = (2*x)/(a*b)
    s = (n**2 + b**2)**0.5
    print(math.degrees(math.asin(b/s)))
else:
    n = (2*x) / (a**2) - b
    a = a + a*(n/b)
    s = (a**2 + b**2)**0.5
    print(math.degrees(math.asin(b/s)))

Submission status: Wrong Answer

Solution code:
import math

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

if (a**2*b / 2) <= x:
    theta = 90 - 180 * math.atan(2 * (a**2 * b - x)/a**3) / 3.1415926
else:
    theta = 180 * math.atan(x / (a * b ** 2)) / 3.1415926

print(90 - theta)

Submission status: Wrong Answer

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

h = x/(a**2)

angle = math.atan((b-h)/(a/2))
print(math.degrees(angle))

Submission status: Wrong Answer

Solution code:
import sys
import math
stdin = sys.stdin
mod = 10**9 + 7

ns = lambda: stdin.readline().rstrip()
ni = lambda: int(ns())
na = lambda: list(map(int, stdin.readline().split()))
sa = lambda h: [list(map(int, stdin.readline().split())) for i in range(h)]

a, b, x = na()
s = x/a
tri = a*b/2
print(s, tri)
if tri <= s:
    si = a * b - s
    print(math.degrees(math.atan(2 * si/a**2)))
else:
    print(90.0 - math.degrees(math.atan(2 * s/b**2)))

Submission status: Wrong Answer

Solution code:
import math
a, b, x = map(int, input().split())
ans1 = 0
ans2 = 0
if a > b:
    ans1 = math.atan2(2 * x, a * a * a)
    ans1 *= 180 / math.pi
    ansA = ans1
else:
    ans2 = math.atan2(2 * x, b * b * b)
    ans2 *= 180 / math.pi
    ans2 = 90 - ans2
    ansA = ans2

# print(math.atan2(2 * x, b * b * b))
ans3 = math.atan2(2 * (a * a * b - x), a * a * a)
if a * math.tan(ans3) > b:
    ans3 = ansA
else:
    ans3 *= 180 / math.pi

ans = min(ans3, ansA)
print(ans)

Submission status: Wrong Answer

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

Submission status: Wrong Answer

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

Submission status: Wrong Answer

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

Submission status: Wrong Answer

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

Submission status: Wrong Answer

Solution code:
import math
a,b,x = map(int, input().split())
print(math.degrees(math.atan(a*b*b/2/x)))

Submission status: Wrong Answer

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

Submission status: Wrong Answer

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

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

Submission status: Wrong Answer

Solution code:
n, k, c = map(int, input().split())
t = n*n*k
t1 = max((c/t) * 90, (90 - (c/t)*90))
print("{0:10f}".format(t1))

Submission status: Wrong Answer

Solution code:
import math
import os
import sys
# from fractions import gcd
input = sys.stdin.readline

sys.setrecursionlimit(2147483647)
INF = float("inf")
IINF = 10 ** 18
MOD = 10 ** 9 + 7


def main():
    a, b, x = list(map(int, input().split()))

    h = x / float(a ** 2)
    remain = b - h
    ans = math.degrees(math.atan2(remain, a/2))

    if ans <= 45.0:
        print(ans)
    else:
        # x = b * a * t / 2
        t = 2 * x / (b * a)
        deg = math.degrees(math.atan2(b, t))
        print(deg)


if __name__ == '__main__':
    main()

Submission status: Wrong Answer

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

Submission status: Wrong Answer

Solution code:
import math

a,b,x=map(int,input().split())
if b>a or x<a*a*b//2:
    q=math.degrees(math.atan(a*b*b/(2*x)))
else:
    q=math.degrees(math.atan(2*(a*a*b-x)/(a**3)))
print('{:.10f}'.format(q))

Submission status: Wrong Answer

Solution code:
import math
a, b, x = map(int, input().split())
ans1 = 0
ans2 = 0
if a > b:
    ans1 = math.atan2(2 * x, a * a * a)
    ans1 *= 180 / math.pi
    ansA = ans1
else:
    ans2 = math.atan2(2 * x, b * b * b)
    ans2 *= 180 / math.pi
    ans2 = 90 - ans2
    ansA = ans2

# print(math.atan2(2 * x, b * b * b))
ans3 = math.atan2(2 * (a * a * b - x), a * a * a)
if a * math.tan(ans3) > b:
    ans3 = ansA
ans3 *= 180 / math.pi

ans = min(ans3, ansA)
print(ans)

Submission status: Wrong Answer

Solution code:
import sys
import math
input = sys.stdin.readline


def main():
    a, b, x = map(int, input().split())
    h = 2 * x / (a * b)
    ans = math.atan(a * (b ** 2) / (2 * x))
    print(math.degrees(ans))


if __name__ == '__main__':
    main()

Submission status: Wrong Answer

Solution code:
import sys
import math
a, b, x = map(int, input().split())
rest = a * a * b - x

if rest == 0:
    print(0)
    sys.exit()

if x >= a * a * b / 2:
    temp = 2 * rest / (a*a)
    ans = math.degrees(math.atan(temp / a))
    print(ans)
else:
    temp = 2 * x / (b*b)
    ans = math.degrees(math.atan(b / temp))
    print(ans)

Submission status: Wrong Answer

Solution code:
def main():
    import math
    a,b,x=map(int,input().split())
    v=a*a*b
    if x==0:
        print(0)
    elif x==v:
        print(90)
    elif x<v/2:
        h=2*x/(a*b)
        t=math.degrees(math.atan(h/b))
        print(90-t)
    else:
        h=2*(v-x)/(a*a)
        t=math.degrees(math.atan(h/a))
        print(t)
        
main()

Submission status: Wrong Answer

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

Submission status: Wrong Answer

Solution code:
import math

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

Submission status: Wrong Answer

Solution code:
import sys
import math
from fractions import Fraction

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

y = Fraction(x / (a ** 2))

if y == b:
    print(0)
    sys.exit()

if b >= a:
    a = Fraction(2 * a * y / b)
    teihen = b
else:   
    teihen = 2 * (b - y)
res = Fraction(a / teihen)
print(90 - math.degrees(math.atan(res)))

Submission status: Wrong Answer

Solution code:
import math
a,b,x=map(int,input().split())
print(math.degrees(math.atan(a*b*b/(2*x))))

Submission status: Wrong Answer

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

Submission status: Wrong Answer

Solution code:
import math
a,b,x = map(int,input().split())
y = ( 2 * x ) / ( a * b )
ans = math.degrees(math.atan(b/y))
print(ans)

Submission status: Wrong Answer

Solution code:
import math


a, b, x = map(int, input().split())
t = x / a / a
maxim = b-t

ans = math.degrees(math.atan(2*maxim/a))
print(ans)

Submission status: Wrong Answer

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

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

Submission status: Wrong Answer

Solution code:
a, b, x = map(int,input().split())
s = x/a
import math
if (a*b / 2 <= s):
  h = 2*s/a
  rad = math.atan(h/b)
  print(90.0 - math.degrees(rad))
else:
  rest = a*b - s
  l = 2*rest/a
  rad = math.atan(a/l)
  print(90.0 - math.degrees(rad))

Submission status: Wrong Answer

Solution code:
from math import *
a,b,x=input().split()
a=float(a)
b=float(b)
x=float(x)
if x>a*a*b:
	y = 2*(a*a*b-x)/(a*a*a)
elif x==(a*a*b)/2:
	y = b/a
else:
	y=(a*b*b)/(2*(x))
ans=(atan(y)*180)/pi
print(ans)

Submission status: Wrong Answer

Solution code:
import sys
sys.setrecursionlimit(int(1e6))

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

import math

m = a*a*b - x
n = m / (a*a)
ans_rad = math.atan(n / (a/2))
ans = ans_rad * 180 / math.pi
print(ans)

Submission status: Wrong Answer

Solution code:
import math

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

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

Submission status: Wrong Answer

Solution code:
import math

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

half_volume = a*b / 2

if x >= half_volume:
    angle = math.atan(2*(b-x/a**2)/a) * 180 / math.pi
else:
    value = 2 * x / (a * b ** 2)
    angle = 90 - math.atan(value) * 180 / math.pi

print(angle)

Submission status: Wrong Answer

Solution code:
import math
a,b,x = map(float,input().split())
theta = math.degrees(math.atan((2. * (((a ** 2) * b) - x)) / (a ** 3)))
print(theta)

Submission status: Wrong Answer

Solution code:
import math

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

# 45度より傾けても大丈夫な場合
if x < a*a*b / 2.0:
  # 底面の水に触れてる長さをhとする
  h = 2.0 * float(x) / (float(b) * float(a))
  rad = math.atan2(b, h)
else:
  # こぼれるぎりぎりの、傾ける反対側の面の水の触れていない長さをhとする
  h = 2.0 * (float(b) - float(x) / float(a*a))
  rad = math.atan2(h, a)

  print(math.degrees(rad))

Submission status: Wrong Answer

Solution code:
#!/usr/bin/env python3
from math import pi, atan
a, b, x = map(int, input().split())
y = x / a
if y / b < a / 2:
    d = y / b
    th = pi / 2 - atan(2 * d / b)
else:
    d = y / a
    th = pi / 2 - atan(2 * (b - d) / a)
if a > b:
    th = pi / 2 - th
print(th * 180 / pi)

Submission status: Wrong Answer

Solution code:
#!/usr/bin/env python3
import sys
args = sys.argv
if len(args) == 2:
  from IPython import embed
  em = True
else:
  em = False
input = sys.stdin.readline
a, b, x = map(int, input().split())
if a**2*b == x:
  print(0)
  exit()
import math
if 2*x/b <= a:
  t1 = a*b**2
  t2 = 2*x
  ans = math.degrees(math.atan(t1/t2))
else:
  t1 = a**3
  t2 = 2*a**2*b - 2*x
  ans = 90 - math.degrees(math.atan(t1/t2))
print(ans)
if em: sys.stdin = open('/dev/tty')

Submission status: Wrong Answer

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

Submission status: Wrong Answer

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

Submission status: Wrong Answer

Solution code:
import math
k=list(map(int,input().split()))
a = int(k[0])
b = int(k[1])
x = int(k[2])
t = x/a**2
if(t * 2 > b):
    i = 2*(b - t)/a
    print(i)
    print(math.degrees(math.atan(i)))
else:
    i = 2*x/(a*b**2)
    print(90 - math.degrees(math.atan(i)))

Submission status: Wrong Answer

Solution code:
import math

a,b,x=map(int,input().split())
if b>a or x<a*a*b//2:
    q=math.acos(x/(a*a*b))
else:
    q=math.atan(2*(a*a*b-x)/(a**3))
print('{:.10f}'.format(math.degrees(q)))

Submission status: Wrong Answer

Solution code:
import math
a, b, x = input().split()
a=int(a)
b=int(b)
x=int(x)
volume = a * a * b
if x<(volume/2):
    state=-1 #반보다 적을때
else:
    state=1 #반이상

if state==-1:
    angle=90-math.degrees(math.atan(x/(b*b)))
else:
    angle=math.degrees(math.atan((volume-x)/(a*a)))
print(angle)

Submission status: Wrong Answer

Solution code:
from math import *
a,b,x=input().split()
a=float(a)
b=float(b)
x=float(x)
if x>=a*a*b:
	y = 2*(a*a*b-x)/(a*a*a)
else:
	y=(a*b*b)/(2*(x))
ans=(atan(y)*180)/pi
print(ans)

Submission status: Wrong Answer

Solution code:
a, b, x = map(float, input().split(' '))
y = 2*b-(2*x/a**2)
import math
print(math.degrees(math.atan(y/a)))

Submission status: Wrong Answer

Solution code:
import math
a,b,x=map(int,input().split())
y=2*(b-x/a/a)
print(math.asin(y/math.sqrt(y*y+a*a))*180/math.pi)

Submission status: Wrong Answer

Solution code:
import math
a,b,v=map(int,input().split())
theta1=0
theta2=math.pi/2
ans=10**9
if a*a*b-v==0:
    print(90)
    exit()
if a*a*b/2>=v:
    while 1:
        tmp=math.tan((theta1+theta2)/2)-2*v/(a*b*b)
        if abs(tmp)<=10**(-6):
            ans=(theta1+theta2)/2
            break
        else:
            if tmp>0:
                theta2=(theta1+theta2)/2
            else:
                theta1=(theta1+theta2)/2
else:
    while 1:
        tmp=math.tan((theta1+theta2)/2)-(a**3)/(2*(a*a*b-v))
        if abs(tmp)<=10**(-6):
            ans=(theta1+theta2)/2
            break
        else:
            if tmp>0:
                theta2=(theta1+theta2)/2
            else:
                theta1=(theta1+theta2)/2
print(90-math.degrees(ans))

Submission status: Wrong Answer

Solution code:
import math

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

if(a*a*b < x/2):
    y = 2 * (a**2*b - x) / (a**2)
    ans = math.degrees(math.atan2(a, y))
elif(a*a*b == x/2):
    ans = 45
else:
    y = 2*x / (b*a)
    ans = math.degrees(math.atan2(b, y))

print(ans)

Submission status: Wrong Answer

Solution code:
import math
a,b,x = (int(i) for i in input().split())

ans = math.degrees(math.atan(2*(a**2*b-x)/a**3))
print(ans)

Submission status: Wrong Answer

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

Submission status: Wrong Answer

Solution code:
# coding: utf-8
# Your code here!
import math

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

if x==a**2*b:
    print(90)
    exit()

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

Submission status: Wrong Answer

Solution code:
#%%
import math 

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

Submission status: Wrong Answer

Solution code:
import math
a,b,x =map(int,input().split( ))
if x >= (a**2*b/2):
    k=2*x/(a**2)-b
    cos=math.sqrt((b-k)**2/((a**2)+(b-k)**2))
    print(math.degrees(math.acos(cos)))
else:
    k=2*x/(a*b)
    cos=math.sqrt(b**2/(b**2+k**2))
    print(90-math.degrees(math.acos(cos)))

Submission status: Wrong Answer

Solution code:
import math
a,b,x = (int(i) for i in input().split())

y = 2*(a**2*b-x)/a**3
ans = math.degrees(math.atan(y))
print(ans)

Submission status: Wrong Answer

Solution code:
import numpy as np
a,b,x=map(int,input().split())
ans = np.rad2deg(np.arctan(2*(b-x/a**2)/a))
if ans <= 45:
    print(ans)
else:
    ans=np.rad2deg(np.arctan(b/(2*x/a/b)))
    print(ans)

Submission status: Wrong Answer

Solution code:
import math

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

h = x / a**2.0

theta = math.atan(2.0*(b-h)/a)

if math.tan(theta) > a / b:
    theta = math.atan((a*b**2)/(2.0*x))

print(math.degrees(theta))

Submission status: Wrong Answer

Solution code:
import math

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

h = x/(a**2)
men = a*h
m = men * 2/b

rad = math.atan(b/m)
print(math.degrees(rad))

Submission status: Wrong Answer

Solution code:
import math
def main():

    a, b, x = map(int, input().split())
    if x <= a*a*b/2:
        y = 2*x/a/b
        print(a, y)
        print(math.atan(b/y))
        return 180*math.atan(b/y) / (math.atan(1) * 4)
    else:
        y = (x - b*a*a/2)/(a*a/2)
        print(a*a*b-(b-y)*a*a/2)
        print(y)
        return 180*math.atan((b-y)/a) / (math.atan(1) * 4)


if __name__ == '__main__':
    print(main())

Submission status: Wrong Answer

Solution code:
a, b, x = map(int, input().split())
print(x ** (1/3))

Submission status: Wrong Answer

Solution code:
import math

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

y=2*x/(a*b)
arg=math.asin(b/math.sqrt(y**2+b**2))
deg=math.degrees(arg)

print(deg)

Submission status: Wrong Answer

Solution code:
import math
a,b,x = map(int,input().split())
ok = 0.0
ng = 90.0
z = math.degrees(math.atan2(b,a))

def f(y):
    if y >= z:
        return b*b*a/(math.tan(math.radians(y))*2.0)
    else:
        print(math.tan(y))
        return a*a*b-a*a*a*math.tan(math.radians(y))/2.0


for _ in [0]*1000:
    mid = (ok+ng)/2
    if f(mid) >= x:
        ok = mid
    else:
        ng = mid

print(ok)

Submission status: Wrong Answer

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

if 2*x/(a**2) > b:
    c = 2*x/(a**2) - b
    rad = math.acos(a/math.sqrt(c**2 + a**2))
    deg = math.degrees(rad)
    ans = 90 - deg
else:
    c = 2*x/a/b
    h = b * c / math.sqrt(b**2 + c**2)
    rad = math.acos(h/b)
    deg = math.degrees(rad)
    ans = deg
    
print(ans)

Submission status: Wrong Answer

Solution code:
from math import *
a,b,x=input().split()
a=float(a)
b=float(b)
x=float(x)
y = 2*(a*a*b-x)/(a*a*a)
ans=(atan(y)*180)/pi
print(ans)

Submission status: Wrong Answer

Solution code:
import math
import sys
a,b,x = map(int,input().split())
print(a,b,x)
s=0
v=a*a*b

for i in range(0,900000000,1):
  ra=math.radians(i/10000000)
  left_v=a*a*a*math.tan(ra)/2
  if(v-left_v<=x):
    print(i/10000000)
    sys.exit()

Submission status: Wrong Answer

Solution code:
import math

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

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

# ラジアンを度に変換
deg = math.degrees(rad)

print(deg)

Submission status: Wrong Answer

Solution code:
import math

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

Submission status: Wrong Answer

Solution code:
import math

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

tmp = (2*a**2*b-2*x)/a**3
theta0 = math.degrees(math.atan(tmp))

aa = (2*b-a*math.tan(math.radians(theta0)))*a**2/2

theta1 = math.degrees(math.atan(2*x/a**3))
bb = a**3*math.tan(math.radians(theta1))


theta2 = math.degrees(math.atan(a*b**2/(2*x)))
cc = a*b**2/(2*math.tan(math.radians(theta2)))

diff = [(abs(x-aa), theta0), (abs(x-bb), theta1), (abs(x-cc), theta2)]
diff = sorted(diff)
print(diff[0][1])

Submission status: Wrong Answer

Solution code:
import sys
import math
a, b, x = map(int, input().split())
rest = a * a * b - x

if rest == 0:
    print(0)
    sys.exit()

x = 2 * rest / (a*a)
ans = math.degrees(math.atan(x / a))
# print(rest)
# print(x)
#print(math.degrees(math.atan(x)))

print(ans)

Submission status: Wrong Answer

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

Submission status: Wrong Answer

Solution code:
import math
a,b,x = (int(i) for i in input().split())

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

Submission status: Wrong Answer

Solution code:
import math
a,b,x = map(int,input().split())
value = (b-(x/a**2))/(a/2)
atan = math.degrees(math.atan(value))
if atan <= 45.0:
    print(atan)
    exit()
atan = math.degrees(math.atan((2*x)/(a*b*b)))
print(90-atan)

Submission status: Wrong Answer

Solution code:
a, b, x = map(int, input().split())
c = a**2 * b
print(90.0000000*(c-x)/c)

Submission status: Wrong Answer

Solution code:
import math
A,B,X=map(int,input().split())
X/=A
tan=B**2/(2*X)
print(math.degrees(math.atan(tan)))

Submission status: Wrong Answer

Solution code:
import math
a,b,c=map(int,input().split())
d=b-c/(a**2)
d=d*2
if d==0:
  print(0)
elif d>a:
  e=(c*2)/(a*b)
  print(math.degrees(math.atan(b/e)))
else:
  print(math.degrees(math.atan(d/a)))

Submission status: Wrong Answer

Solution code:
import math
a,b,x=map(int,input().split())
c=(a*b*b)/(2*x)
asin=math.degrees(math.atan(c))
print(asin)

Submission status: Wrong Answer

Solution code:

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

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

Submission status: Wrong Answer

Solution code:
import math

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

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

print(si)

Submission status: Wrong Answer

Solution code:
from math import atan
from math import pi

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

if a * b <= x:
    ans = atan((2 * b) / a - 2 * x / (a ** 3))
    ans = ans * 180 / pi
else:

    ans = atan(2 * x / (a * (b ** (2))))
    ans = ans * 180 / pi
    ans = 90 - ans

print(ans)

Submission status: Wrong Answer

Solution code:
import math
a,b,x=map(int,input().split())
S=a*b
s=x/a
if S/2<=s:
  l=2*s/a-b
  print(math.degrees(math.atan((b-l)/a)))
else:
  l=2*s/b
  print(90-math.degrees(math.atan(b/l)))

Submission status: Wrong Answer

Solution code:
import math
k=list(map(int,input().split()))
a = int(k[0])
b = int(k[1])
x = int(k[2])

i = 2*x/(a*b**2)
print(90 - math.degrees(math.atan(i)))

Submission status: Wrong Answer

Solution code:
import math
a, b, x=(int(i) for i in input().split())

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

Submission status: Wrong Answer

Solution code:
from math import atan2,pi
a,b,x = map(int,input().split())

h = 2*x/(a*b)
ans1 = atan2(b, h)

ans2 = atan2(b-x/(a*a), a/2)

if a>b:
    print(ans2/pi*180)
else:
    print(ans1/pi*180)

Submission status: Wrong Answer

Solution code:
import math

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

t = 2*(b*a*a - x)/a/a/a
theta = math.atan(t) * 180 / math.pi

print(theta)

Submission status: Wrong Answer

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

import numpy as np
from numpy import linalg as LA

if a*a*b<=x:
  sanMenseki=(a*a*b-x)/a
  takasa=sanMenseki*2/a
  u = np.array([a,0])
  v = np.array([a,takasa])
  i = np.inner(u, v)
  n = LA.norm(u) * LA.norm(v)

  c = i / n
  a = np.rad2deg(np.arccos(np.clip(c, -1.0, 1.0)))

  print(a)
else:
  sanMenseki=x/a
  takasa=sanMenseki*2/b
  u = np.array([b,0])
  v = np.array([b,takasa])
  i = np.inner(u, v)
  n = LA.norm(u) * LA.norm(v)

  c = i / n
  a = np.rad2deg(np.arccos(np.clip(c, -1.0, 1.0)))

  print(90-a)

Submission status: Wrong Answer

Solution code:
import math
a,b,x = map(int,input().split())
ans = math.degrees(math.atan(2*x/a*b*b))
print(ans)

Submission status: Wrong Answer

Solution code:
from math import atan
from math import pi

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

if a * b <= x:
    ans = atan((2 * b) / a - 2 * x / (a ** 3))
    ans = ans * 180 / pi
else:
    print(1)
    ans = atan(2 * x / (a * (b ** (2))))
    ans = ans * 180 / pi
    ans = 90 - ans

print(ans)

Submission status: Wrong Answer

Solution code:
import numpy as np

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

v = a*a*b

if v == x:
    print(0)
    exit(0)

h = (2*x)/(a*a)

t = np.arctan(h/a)

print(t*180/np.pi)

Submission status: Wrong Answer

Solution code:
import math

def main():
  a, b, x = map(int, input().split())
  box = a * a * b
  fill_rate = x / box
  print("fill_rate:",fill_rate)
  if fill_rate > 0.5:
    height = b * (1 - fill_rate)
    print("height:",height)
    width = a / 2
    print("width:",width) 
  else:
    area_size = a * b * fill_rate
    width = area_size / b * 2
    height = b
  result_radian = math.atan(height/width)
  result = result_radian / math.pi * 180
  return result

print(main())

Submission status: Wrong Answer

Solution code:
W, H, X = map(int, input().split())
X /= W
if W*H==X:
    print(0)
    quit()
import math
angle = 90 - math.atan(2*X/pow(H,2)) * 180/math.pi
if angle >= 45:
    print(angle)
else:
    angle = 90 - math.atan(W*W/(2*(W*H-X))) * 180/math.pi
    print(angle)

Submission status: Wrong Answer

Solution code:
import math

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

angle = math.atan(a * b * b / (2 * x)) * 180 / math.pi

print(angle)

Submission status: Wrong Answer

Solution code:
import numpy as np
pi=np.pi
a,b,x=map(int,input().split())
if 0<=2*x/(a**2)-b<b:
  y=2*x/(a**2)-b
  print(np.arctan((b-y)/a)/pi*180)
else:
  y=(2*x)/(a*b)
  z=(b*b+y*y)**(1/2)
  h=(b*y)/z
  print(np.arccos(h/b)/pi*180)

Submission status: Wrong Answer

Solution code:
import math

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

t = 2*(b/a - x/a**3)
theta = math.atan(t) * 180 / math.pi

print(theta)

Submission status: Wrong Answer

Solution code:
a, b, x = list(map(int, input().split()))
ma = a*a*b

import math
y = 2*(ma-x)/(a*a*a)
ans = math.degrees(math.atan(y))

if (ans > 45):
  y = a*b*b/(2 * x)
  ans = math.degrees(math.atan(y))
  print(ans)
else:
  print(ans)

Submission status: Wrong Answer

Solution code:
import math


def to_angle(x):
    return x * 180 / math.pi


def main():
    a, b, x = map(float, raw_input().split())
    v = a * a * b
    if v <= x * 2:
        print(to_angle(math.atan(2 * (v - x) / a ** 3)))
    else:
        print(to_angle(math.atan(b ** 3 / x * 0.5)))



main()

Submission status: Wrong Answer

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

Submission status: Wrong Answer

Solution code:
import math
a, b, x = map(int, input().split())
y = a*a*b - x
if y == 0:
  print(90)
  exit()

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

Submission status: Wrong Answer

Solution code:
import numpy as np
a,b,x=map(int,input().split())
k=2*(a*a*b-x)/(1.0*a*a*a)
l=2*x/(1.0*a*b*b)
if a*b*a/2.0<x:
    print(np.rad2deg(np.arctan(k)))
else:
    print(np.rad2deg(np.arctan(l)))

Submission status: Wrong Answer

Solution code:
a,b,x = map(int,input().split())
y = (a*b*b) / (2*x)
import math
#print(y)
if y >= 1:
  print(math.degrees(math.atan(y)))
else:
  z = (2*a*a*b-2*x) / (a*a*a)
  print(math.degrees(math.atan(z)))

Submission status: Wrong Answer

Solution code:
from math import *
a,b,x=map(int,input().split())
# print (asin(1))
if x <= a ** 2 * b / 2:
    print (asin(b / 2 / sqrt(b ** 2 + (2 * x / a / b) ** 2)) * 180 / pi)
else:
    print (atan((2 * a ** 2 * b - 2 * x) / a ** 3) * 180 / pi)

Submission status: Wrong Answer

Solution code:
import math
a,b,c=map(int,input().split())
d=b-c/(a**2)
d=d*2
if d==0:
  print(0)
elif d>a:
  e=c*2/(a*b)
  print(90-math.degrees(math.atan(e/b)))
else:
  print(90-math.degrees(math.atan(a/d)))

Submission status: Wrong Answer

Solution code:
from math import atan, degrees

a,b,x = map(int,input().split())
if a * a * b == x * 2:
    print(45)
elif a * a * b / 2 > x:
    t = 2 * x / (a * b * b)
    print(90 - degrees(atan(t)))
else:
    h = (2 / a) * (a * b - x / a)
    print(degrees(h / a))

Submission status: Wrong Answer

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

if x >=2*b*a**2:
    h = b*2 - (2*x/a**2)
    tan = h/a
    ans = math.atan(tan)/math.pi *180
    print(ans)


else:
    w = 2*x/(a*b)
    tan = b/w
    ans = math.atan(tan)/math.pi *180
    print(ans)

Submission status: Wrong Answer

Solution code:
import math
a,b,x = map(int,input().split())
print(math.degrees(math.asin(math.sqrt(x/(a**2*b)))))

Submission status: Wrong Answer

Solution code:
import numpy as np
a,b,x=map(int,input().split())
k=2*(a*a*b-x)/(1.0*a*a*a)
print(np.rad2deg(np.arctan(k)))

Submission status: Wrong Answer

Solution code:
import math

a, b, x = list(map(int, input().split()))
print(math.degrees(math.atan2(b, 2 * x / a / b)))