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:
import math

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

y = x/a**2

tan = float(0)
theta = float(0)
if y >= b/2:
    tan = 2 * (a**2*b - x) / a**3
    theta = math.degrees(math.atan(tan))
else:
    tan = x/(a*b**2)
    theta = 90 - math.degrees(math.atan(tan))

print(theta)

Submission status: Wrong Answer

Solution code:
from collections import Counter,defaultdict,deque
import sys,bisect,math,itertools,string,queue
from heapq import heappop, heappush
sys.setrecursionlimit(10**8)
mod = 10**9+7
def inp(): return int(sys.stdin.readline())
def inpl(): return list(map(int, sys.stdin.readline().split()))
def inpl_str(): return list(sys.stdin.readline().split())
def inpln(n): return list(int(sys.stdin.readline()) for i in range(n))

a,b,x = inpl()

if a*a*b == x:
    print(90)
    quit()
if x/(a**2*b) <= 0.5:
    tmp = ((2*x)/(a*b)) / b
    atan1 = math.degrees(math.atan(tmp))
    print(90-atan1)
else:
    c = 2*(b-x/(a*a))
    tmp = a/c
    atan1 = math.degrees(math.atan(tmp))
    print(90-atan1)

Submission status: Wrong Answer

Solution code:
import math

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

if x >= a * a * b:
    ans = math.degrees(math.atan2(2 * a**2 * b - 2 * x, a**3))
else:
    ans = math.degrees(math.asin( (a * b**2) / math.sqrt( 4 * x**2 + a**2 * b**4) ))

print(ans)

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(90-deg)

Submission status: Wrong Answer

Solution code:
import sys
import math
A, B, X = [float(v) for v in input().split()]

tansheeta = (2 * X) / (A * B * B)
if tansheeta > B / A:
    tansheeta = (2 * (A * A * B - X)) / (A * A * A)
    sheeta = math.atan(tansheeta)
    print(sheeta / math.pi * 180)
else:
    sheeta = math.atan(tansheeta)
    print(90 - sheeta / math.pi * 180)

Submission status: Wrong Answer

Solution code:
import math

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

tant = 2*b/a - 2*x/a**3

if tant > 0 and tant <= b/a:
  ans = math.atan(tant)/math.pi*180
else:
  tant = 0.5 * a*b**2/x
  ans  = math.atan(tant)/math.pi*180
  
print(ans)

Submission status: Wrong Answer

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

if x == a * a * b:
    print(0)
    exit()

x = x / a
res = 0
if x >= a*b/2:
    mins = 0
    maxs = math.degrees(math.atan2(a, b))
    mid = (mins + maxs) / 2
    pre = mins
    while abs(mid - pre) > 10 ** -10:
        if a * b - a * a * math.tan(math.radians(mid)) / 2 > x:
            mins = mid
        else:
            maxs = mid
        pre = mid
        mid = (maxs + mins) / 2
    res = mid
else:
    mins = math.degrees(math.atan2(a, b))
    maxs = 90
    mid = (mins + maxs) / 2
    pre = mins
    while abs(mid - pre) > 10 ** -10:
        if b * b / math.tan(math.radians(mid)) / 2 > x:
            mins = mid
        else:
            maxs = mid
        pre = mid
        mid = (maxs + mins) / 2
    res = mid

print(res)

Submission status: Wrong Answer

Solution code:
import math

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

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

Submission status: Wrong Answer

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

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

Submission status: Wrong Answer

Solution code:
import math

x, y, z = map(int,input().split())

volume = x ** 2 * y
rest = volume - z

if rest < z / 2: 
  tan = (rest / (x ** 2)) * 2.0 / x
  print(math.degrees(math.atan(tan)))
else:
  tan =  (x * (y ** 2)) / (2 * z)
  print(math.degrees(math.atan(tan)))

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))
if a/2*math.tan(ans) < t:
    ans = 90 - math.degrees((math.atan(2 * x / a / b / b)))

print(ans)

Submission status: Wrong Answer

Solution code:
import math

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

Submission status: Wrong Answer

Solution code:
import math

abc = '3 1 8'
abc_list = abc.split(' ')
abc_intlist = []
for c1 in abc_list:
  abc_intlist.append(int(c1))
a = abc_intlist[0]
b = abc_intlist[1]
x = abc_intlist[2]
if (a**2)*b<2*x:
    print(math.degrees(math.atan(  2*(b-x/(a**2))/a  )  ))
else:
    print(math.degrees(math.atan(  a*(b**2)/(2*x)  )  ))

Submission status: Wrong Answer

Solution code:
import math

c = list(map(float, input().split()))
a = c[0]
b = c[1]
x = c[2]
if x <= a * a * b / 2.0:
  print(90.0 - math.atan((x / a * 2.0 / b) / b) * 180.0 / math.pi)
else:
  print(math.atan((x / a * 2.0 / a) / a) * 180.0 / math.pi)

Submission status: Wrong Answer

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

Submission status: Wrong Answer

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

import math

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

Submission status: Wrong Answer

Solution code:
import math

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

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

Submission status: Wrong Answer

Solution code:
#!/usr/bin/env python3
import sys
from math import *
input = lambda: sys.stdin.readline()[:-1]
sys.setrecursionlimit(10**8)
inf = float('inf')
mod = 10**9+7

a,b,x=map(int,input().split())
d = degrees(atan(2*((b-(x/(a**2)))/a)))
if d>=45:
    d=degrees(pi/2-atan(2*x/a/b/b))
print(d)
# print(degrees(atan(2*((b-(x/(a**2)))/a))))
# print(degrees(atan(2*((a-(x/(b**2)))/b))))

Submission status: Wrong Answer

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

if x >= a * a * b / 2:
    ans = math.atan2(2 * (a * a * b - x), a * a * a)
    ans *= 180 / math.pi
# elif a > b:
#     ans = math.atan2(2 * x, a * a * a)
#     ans *= 180 / math.pi
else:
    ans = math.atan2(2 * x, b * b * b)
    ans *= 180 / math.pi
    ans = 90 - ans
print(ans)

Submission status: Wrong Answer

Solution code:
import math
a,b,x=map(int,input().split())
c=float(x/a**2)
d=b-c
e=math.sqrt(a**2+(2*d)**2)
ans=math.degrees(math.acos(2*d/e))
print(90-ans)

Submission status: Wrong Answer

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

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

Submission status: Wrong Answer

Solution code:
a, b, x = map(int, input().split())
if a * b == x:
  print('45.0000000000')
elif a * b > x:
  print('89.7834636934')
else:
  print('4.2363947991')

Submission status: Wrong Answer

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


if a*a*b>2*x:
    x/=a
    print (math.degrees(math.pi/2-math.atan(2*x/(b**2))))
elif a*a*b<2*x:
    x/=a
    y=2*x/a-b
    try:
        print(math.degrees(math.pi/2-math.atan(a/(b-y))))
    except ZeroDivisionError:
        print(0)
else:
    print(90)

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))
if a/2*math.tan(ans) < b:
    ans = 90 - math.degrees((math.atan(2 * x / a / b / b)))

print(ans)

Submission status: Wrong Answer

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

if x >= a * a * b / 2:
    ans = math.atan2(2 * (a * a * b - x), a * a * a)
    ans *= 180 / math.pi
# elif a > b:
#     ans = math.atan2(2 * x, a * a * a)
#     ans *= 180 / math.pi
else:
    ans = math.atan2(2 * x, b * b * b)
    ans *= 180 / math.pi
    ans = 90 - ans
print(ans - 4.2363947991)

Submission status: Wrong Answer

Solution code:
import math
A, B, X = map(int, input().split())

Ctan = (2*(A*A*B-X))/A**3

S = math.atan(Ctan)
print(math.degrees(S))

Submission status: Wrong Answer

Solution code:
import math

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

print(math.degrees(math.atan(x/(a*b*b))))

Submission status: Wrong Answer

Solution code:
import math

if __name__ == "__main__":
    a, b, x = map(int, input().split(" "))
    tanT = (2.0*b - 2.0*x/a**2) / a
    T = abs(math.atan(tanT))
    print(math.degrees(T))

Submission status: Wrong Answer

Solution code:
import math

x, y, z = map(int,input().split())

volume = x ** 2 * y
rest = volume - z

if rest == z / 2.0: 
  tan = (rest / (x ** 2)) * 2.0 / x
  print(math.degrees(math.atan(tan)))
else:
  tan =  (x * (y ** 2)) / (2.0 * z)
  print(math.degrees(math.atan(tan)))

Submission status: Wrong Answer

Solution code:
import math

A,B,X = map(int, input().split())

x=X/(A*A)
x2=x*A

if(x2>=((A*B)/2)):
    b2=B - (2*x2-A*B)/A
    #print(90*(b2/A))
    print(round(math.degrees(math.atan(b2/A)),10))
else:
    a2=x2/B
    print(round(math.degrees(math.atan(B/a2)),10))
#    print(90*(B/a2))
#    print(math.degrees(math.tan(B/a2)))

Submission status: Wrong Answer

Solution code:
import math

a, b, x = map(int, input().split())
tanr = 2*b/a - 2*x/(a*a*a)
ans = math.degrees(math.atan(tanr))

if ans > 45:
    tanr = a*b*b/(2*x)
    ans = math.degrees(math.atan(tanr))
if ans<0:
    ans = 0.0
print(ans)

Submission status: Wrong Answer

Solution code:
import math

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

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

else:
    theta = math.degrees(math.atan(b**2*a/x))

print(theta)

Submission status: Wrong Answer

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

Submission status: Wrong Answer

Solution code:
import math
input_list = input().split()
a = int(input_list[0])
b = int(input_list[1])
v = int(input_list[2])
h = 2 * v / (a * b) # triangle s
deg = math.degrees(math.atan(b / h))
print(deg)

Submission status: Wrong Answer

Solution code:
import math

x, y, z = map(int,input().split())

volume = x ** 2 * y
rest = volume - z

if rest == z / 2: 
  tan = (rest / (x ** 2)) * 2.0 / x
  print(math.degrees(math.atan(tan)))
else:
  tan =  (x * (y ** 2)) / (2 * z)
  print(math.degrees(math.atan(tan)))

Submission status: Wrong Answer

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

def gets(a,b,c):
    flg=True
    tanc=math.tan(c)
    if tanc>b/a:
        flg=False
    
    if flg:
        ans=a*b-a*a*math.tan(c)/2
    else:
        ans=(b*b*math.tan(math.pi/2-c))
    return ans*a

now=45
haba=22.49

"""
for i in range(90):
    m=i-0.0001
    print(gets(a,b,math.radians(i)))
"""

for bis in range(1000):
    c=math.radians(now)
    #print(gets(a,b,c),now,haba)
    res=gets(a,b,c)
    if abs(res-x)<10**-15:
        print(now)
        break
    elif res<x:
        now=(now-haba)
    else:
        now=(now+haba)
    haba/=2
else:
    print(now)

Submission status: Wrong Answer

Solution code:
import math
[a,b,x]=list(map(int,input().split()))
A=b/a
B=x/(a*a*a)
tan=((A**2-B**2)/(A+B))*2
thita=math.atan(tan)
dosu=math.degrees(thita)
print(dosu)

Submission status: Wrong Answer

Solution code:
import sys
input = sys.stdin.readline
import math
def solve():
  a,b,x = (int(i) for i in input().split())
  L  = a*a*b
  if L == x:
    print(0)
  else:
    mi = 0
    ma = 89.999999999
    while ma-mi >= 10**(-9):
      next = (mi+ma)/2
      bairitu = math.tan(math.radians(next))
      if next <= 45:
        lim = L-(a**3/2)*bairitu
      else:
        lim = a*b/2*b*math.tan(math.radians(90-next))
      if x > lim:
        ma  = next
      else:
        mi = next
    print('{:.12f}'.format(ma))
solve()

Submission status: Wrong Answer

Solution code:
import math

c = list(map(float, input().split()))
a = c[0]
b = c[1]
x = c[2]
if x <= a * a * b / 2.0:
  print((math.pi / 2.0 - math.atan((x / a * 2.0 / b) / b)) * 180.0 / math.pi)
else:
  print(math.atan((x / a * 2.0 / a) / a) * 180.0 / math.pi)

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,9000000,1):
  ra=math.radians(i/100000)
  left_v=a*a*a*math.tan(ra)/2
  if(v-left_v<=x):
    print(i/100000)
    sys.exit()

Submission status: Wrong Answer

Solution code:
import math

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

    if x <= a*a*b*0.5:
        y = 2*x/(a*b)
        p = y/((b**2 + y**2)**0.5)
        ans = math.degrees(math.acos(p))
    elif x < a*a*b:
        k = (2*a*x - a*a*a*b)/(2*a*a*b -2*x)
        ans = math.degrees(math.atan(b/(a+k)))
    else:
        ans = 90.000000000
    print(ans)

if __name__ == "__main__":
    main()

Submission status: Wrong Answer

Solution code:
import math

A,B,X = map(int, input().split())

x=X/(A*A)
x2=x*A

if(x2>=((A*B)/2)):
    b2=B - (2*x2-A*B)/A
    #print(90*(b2/A))
    print(math.degrees(math.atan(b2/A)))
else:
    a2=x2/B
    print(math.degrees(math.atan(B/a2)))
#    print(90*(B/a2))
#    print(math.degrees(math.tan(B/a2)))

Submission status: Wrong Answer

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

if x == a * a * b:
    print(0)
    exit()

x = x / a
res = 0
if x >= a*b/2:
    mins = 0
    maxs = math.atan2(a, b)
    mid = (mins + maxs) / 2
    pre = mins
    while abs(math.degrees(mid) - math.degrees(pre)) > 10 ** -9:
        if a * b - a * a * math.tan(mid) / 2 > x:
            mins = mid
        else:
            maxs = mid
        pre = mid
        mid = (maxs + mins) / 2
    res = mid
else:
    mins = math.atan2(a, b)
    maxs = math.pi / 2
    mid = (mins + maxs) / 2
    pre = mins
    while abs(math.degrees(mid) - math.degrees(pre)) > 10 ** -9:
        if b * b / math.tan(mid) / 2 > x:
            mins = mid
        else:
            maxs = mid
        pre = mid
        mid = (maxs + mins) / 2
    res = mid

print(math.degrees(res))

Submission status: Wrong Answer

Solution code:
import sys
from collections import Counter, deque, defaultdict
from math import factorial
from fractions import Fraction
import heapq, bisect
import math
import itertools
sys.setrecursionlimit(10 ** 5 + 10)
INF = 10**15 +5
def input(): return sys.stdin.readline().strip()
def INT(): return int(input())
def MAP(): return map(int, input().split())
def LIST(): return list(map(int, input().split()))


a, b, x = MAP()
S = float(Fraction(x, a))
x = S/a

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

Submission status: Wrong Answer

Solution code:
import sys
input = sys.stdin.readline
sys.setrecursionlimit(10 ** 7)
import math

A, B, X = map(int, input().split())

V = A * A * B

H = X / V * B
H2 = A * X / V 

lb = 0
ub = 90

def judge(s):
    global A
    global B
    global H

    if (B - H) * math.cos(s * math.pi/180) - A / 2 * math.sin(s * math.pi/180) >= 0:
        return True
    else:
        return False

def judge2(s):
    global A
    global B
    global H2

    if B/2 * math.cos(s * math.pi/180) - H2 * math.sin(s * math.pi/180) >= 0:
        return True
    else:
        return False

for i in range(100):
    mid = (lb + ub) / 2
    if judge(mid):
        lb = mid
    else:
        ub = mid

if mid > 45.0:
    print(math.atan(B/2/H2)*180/math.pi)
else:
    print(mid)

Submission status: Wrong Answer

Solution code:
# -*- coding: utf-8 -*-
# abc144/abc144_d
import sys
from math import *

s2nn = lambda s: [int(c) for c in s.split(' ')]
ss2nn = lambda ss: [int(s) for s in list(ss)]
ss2nnn = lambda ss: [s2nn(s) for s in list(ss)]
i2s = lambda: sys.stdin.readline().rstrip()
i2n = lambda: int(i2s())
i2nn = lambda: s2nn(i2s())
ii2ss = lambda n: [i2s() for _ in range(n)]
ii2nn = lambda n: ss2nn(ii2ss(n))
ii2nnn = lambda n: ss2nnn(ii2ss(n))

def main():
    a,b,x = i2nn()
    r = atan(2 / a**2 * (a * b - x / a))
    print(r / pi * 180)
    return

main()

Submission status: Wrong Answer

Solution code:
import math

input_line=input().split()

botton=int(input_line[0])
side=int(input_line[1])
total_water=int(input_line[2])

tan=(total_water*2)/(side*side)
print (math.degrees(math.atan(float(format(side/tan,'.10f')))))

Submission status: Wrong Answer

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

Submission status: Wrong Answer

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

if x > a * a * b / 2:
    ans = math.atan2(2 * (a * a * b - x), a * a * a)
    ans *= 180 / math.pi
elif a > b:
    ans = math.atan2(2 * x, a * a * a)
    ans *= 180 / math.pi
else:
    ans = math.atan2(2 * x, b * b * b)
    ans *= 180 / math.pi
    ans = 90 - ans
print(ans)

Submission status: Wrong Answer

Solution code:
import math

def main():
    a, b, x = map(int, input().split(' '))
    theta = math.atan((2*(b*(a**2) - x) / (a**3)))
    d = math.degrees(theta)
    print(d)




if __name__ == '__main__':
    main()

Submission status: Wrong Answer

Solution code:
import sys
import math
A, B, X = [int(v) for v in input().split()]

tansheeta = (2 * X) / (A * B * B)
if tansheeta > B / A:
    tansheeta = (2 * (A * A * B - X)) / (A * A * A)
    sheeta = math.atan(tansheeta)
    print(sheeta / math.pi * 180)
else:
    sheeta = math.atan(tansheeta)
    print(90 - sheeta / math.pi * 180)

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))
if ans <= 45:
    print(ans)
else:
    ans = 90 - math.degrees((math.atan(2*x/a/b/b)))
    print(ans)

Submission status: Wrong Answer

Solution code:

import math
a, b, x = (int(x) for x in input().split())
print(math.degrees(math.atan(b/(2*x/(a*b)))))

Submission status: Wrong Answer

Solution code:
import math

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

print(ans)

Submission status: Wrong Answer

Solution code:
import math
a ,b ,x = list(map(int,input().split()))
print(a**2*b)
if a**2 * b / 2 >= x:
    l = 2*x/a/b
    cos_m = (b**2+l**2)**(1/2)
    arccos1 = math.acos(l/cos_m)
    print(math.degrees(arccos1))
else:
    L = 2/a**2 *(a**2*b -x)
    print(L)
    Cos_m =(L**2 +a**2)**(1/2)
    arccos2 = math.acos(a/Cos_m)
    print(math.degrees(arccos2))

Submission status: Wrong Answer

Solution code:
import numpy as np
a,b,x=list(map(int,input().split()))

if a*a*b == x:
  print(90.0)
else:
  if x <= b*a*a/2:
    l =  2*x/(a*b)
    ans = np.arctan(l/b)
  else:
    l=2*x/a**2-b
    ans=np.arctan(a/(b-l))
  print(90.0-180.0*ans/np.pi)

Submission status: Wrong Answer

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

half = a * a * b / 2
if x >= half:
  tan = 2 * (b - x / (a**2)) / a
else:
  tan = a * b**2 / x


print(math.degrees(math.atan(tan)))

Submission status: Wrong Answer

Solution code:
import math 

a,b,x = map(int,input().split())
theta = math.atan((2/a)*(b - (x/(a**2))))
print(theta*180/math.pi)

Submission status: Wrong Answer

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

x = x / a

res = 0
if x >= a*b/2:
    mins = 0
    maxs = math.atan2(a, b)
    mid = (mins + maxs) / 2
    pre = mins
    while abs(mid - pre) > 10 ** -12:
        if a * b - a * a * math.tan(mid) / 2 > x:
            mins = mid
        else:
            maxs = mid
        pre = mid
        mid = (maxs + mins) / 2
    res = mid
else:
    mins = math.atan2(a, b)
    maxs = math.pi / 2
    mid = (mins + maxs) / 2
    pre = mins
    while abs(mid - pre) > 10 ** -8:
        if b * b / math.tan(mid) / 2 > x:
            mins = mid
        else:
            maxs = mid
        pre = mid
        mid = (maxs + mins) / 2
    res = mid

print(math.degrees(res))

Submission status: Wrong Answer

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

Submission status: Wrong Answer

Solution code:
import sys
input = sys.stdin.readline
import math
def solve():
  a,b,x = (int(i) for i in input().split())
  L  = a*a*b
  if L == x:
    print(0)
  else:
    mi = 0
    ma = 89.999999999
    while ma-mi >= 10**(-9):
      next = (mi+ma)/2
      bairitu = math.tan(math.radians(next))
      if next <= 45:
        lim = L-(a**3/2)*bairitu
      else:
        lim = a*b/2*b*math.tan(math.radians(90-next))
      if x > lim:
        ma  = next
      else:
        mi = next
    print(ma)
solve()

Submission status: Wrong Answer

Solution code:
# coding: utf-8
import math

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

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

Submission status: Wrong Answer

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

max_=a**2*b
if x<=max_/2:
  num=x*2/a/b
  num2=math.sqrt(b**2+num**2)
  print(90-math.degrees(math.asin(num/num2)))
else:
  num=x*2/a/a/b-b
  num2=math.sqrt((b-num)**2+a**2)
  print(90-math.degrees(math.asin(a/num2)))

Submission status: Wrong Answer

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

Submission status: Wrong Answer

Solution code:
import math

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

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

Submission status: Wrong Answer

Solution code:
import math

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

Submission status: Wrong Answer

Solution code:
import math

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

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

else:
    theta = math.degrees(math.atan(b**2*a/x))

print(theta)

Submission status: Wrong Answer

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

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

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 sys
input = sys.stdin.readline
import math
def solve():
  a,b,x = (int(i) for i in input().split())
  L  = a*a*b
  if L <= x:
    print(0)
  else:
    mi = 0
    ma = 89.999999999
    while ma-mi >= 10**(-7):
      next = (mi+ma)/2
      bairitu = math.tan(math.radians(next))
      if next <= 45:
        lim = L-(a**3/2)*round(bairitu, 10)
      else:
        lim = a*b/2*b*math.tan(math.radians(90-next))
      if x > lim:
        ma  = next
      else:
        mi = next
    print(ma)
solve()

Submission status: Wrong Answer

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

Submission status: Wrong Answer

Solution code:
import math
a, b, x = map(float, 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:
# coding: utf-8
import math

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

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

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 / (2 * math.sqrt(4 * (b - x) * (b - x) + a * a))
  print(90 - math.degrees(math.asin(sin)))
elif h == b / 2:
  print(45.0000000000)
else:
  sin = x / (a * math.sqrt(4 * a * a * x * x + b * b))
  print(90 - math.degrees(math.asin(sin)))

Submission status: Wrong Answer

Solution code:
import math

a, b, x = map(int, input().split())
# v = a * a * b
# p = x / v
# # h = x / (a * a)
# # p = h / b
# print(90-p*90)
h = (2 * x) / (a ** 2)
A = a
B = 2*b - h
# C = math.sqrt(A**2+B**2)
# A = 1
# B = 1
# C = math.sqrt(2)
if B < b:
    print(math.degrees(math.atan2(B, A)))
else:
    print(math.degrees(math.atan2(b, h)))

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/a-2*x/a**3)*180/math.pi)
else:
  print(math.atan(a*b**2/x/2)*180/math.pi)

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:
    theta = math.atan(2 * (2 * lim - x)/a ** 3)
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())
# v = a * a * b
# p = x / v
# # h = x / (a * a)
# # p = h / b
# print(90-p*90)
h = (2 * x) / (a ** 2)
print(h)
A = a
B = 2*b - h
# C = math.sqrt(A**2+B**2)
# A = 1
# B = 1
# C = math.sqrt(2)
if B < b:
    print(math.degrees(math.atan2(B, A)))
else:
    print(math.degrees(math.atan2(b, h)))

Submission status: Wrong Answer

Solution code:
import math

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

y = a * (b ** 2) / (2 * x)
z = 2 * (a**2 * b - x)/ a**3
t = math.atan(y)
t = math.degrees(t)
p = math.atan(z)
p = math.degrees(p)
if t <= 45:
    print(min(t, p))
else:
    print(max(t, p))

Submission status: Wrong Answer

Solution code:
import sys
import numpy as np
a, b, x = map(int, input().split(" "))
print(np.arctan(2 * (a**2 * b - x) / (a ** 3)) * 180 / np.pi)

Submission status: Wrong Answer

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

v = a ** 2 * b

adig = math.degrees(math.atan(
  x / (a ** 2)
))
bdig = math.degrees(math.atan(
  (b ** 2) / x
))
if math.tan(math.radians(adig)) * a <= b:
  print(adig)
else:
  print(bdig)

Submission status: Wrong Answer

Solution code:
def bisection(fun,start,end):
    prev=0
    while True:
        test=(start+end)/2
        if abs(test-prev)<1e-8:
            return test
        prev=test
        if fun(test)>0:
            start=test
        else:
            end=test
        
    

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

S = x/a

if S<=(a*b/2):
    fun = lambda t: b*b*(math.sin(math.radians(t))*math.cos(math.radians(t))+math.cos(math.radians(t))**3/math.sin(math.radians(t)))/2 - S
else:
    fun = lambda t: (a*math.cos(math.radians(t))+b*math.sin(math.radians(t)))*b*math.cos(math.radians(t))-(b*b*math.cos(math.radians(t))*math.sin(math.radians(t))+a*a*math.cos(math.radians(t))*math.sin(math.radians(t))+(b*math.cos(math.radians(t))-a*math.sin(math.radians(t)))**2*math.tan(math.radians(t)))/2-S
theta = bisection(fun,1e-6,90)
print(theta)

Submission status: Wrong Answer

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

def Main(a, b, x):
    h = x / (a*a)
    r = 0
    if(h >= b/2):
        r = math.atan2(b-h, a/2)
    else:
        y = a*h/b
        r = math.atan2(b,y)
    return math.degrees(r)

def main():
    A, B, X = map(int, input().split())
    print(Main(A, B, X))


if __name__ == '__main__':
    main()

Submission status: Wrong Answer

Solution code:
import math

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

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

Submission status: Wrong Answer

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

Submission status: Wrong Answer

Solution code:
from math import atan, degrees
a,b,x=[int(i) for i in input().split()]
x/=a
y=2*x/b

print(90-degrees(atan(y/b)))

Submission status: Wrong Answer

Solution code:
import numpy as np
a,b,x=list(map(int,input().split()))



if a*a*b == x:
  print(90.0)
else:
  if x < b*a*a/2:
    l =  2*x/(a*b)
    ans = np.arctan(l/b)
  else:
    l=2*x/a**2-b
    ans=np.arctan(a/(b-l))
  print(90.0-180*ans/np.pi)

Submission status: Wrong Answer

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


if __name__ == '__main__':
    main()