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 = [ int(x) for x in input().split(' ') ]
low, high = 0, math.pi / 2
while high - low > 1e-7:
    alpha = (low + high) / 2
    if math.atan(b/a) < alpha:
        vol = a * (a * b - a * a * math.tan(alpha) / 2)
    else:
        vol = a * (a * b * math.tan(math.pi / 2 - alpha) / 2)
    if vol >= x:
        low = alpha
    else:
        high = alpha
print(low / math.pi * 180)

Submission status: Wrong Answer

Solution code:
from math import tan, atan, degrees, pi
error = 10**(-7)

def calc(th):
    if th > atan(a / b):
        return a**2 * b - a**3 / (2*tan(th))
    else:
        return a * b**2 * tan(th) / 2


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

left = 0.0
right = pi/2
while right - left > error:
    mid = (left + right) / 2
    if calc(mid) <= x: #まだこぼれてない
        left = mid
    else: #こぼれ始めている
        right = mid

ans = (left + right) / 2
print(90 - degrees(ans))

Submission status: Wrong Answer

Solution code:
from math import tan, atan, degrees, pi
error = 10**(-8)

def calc(th):
    if th > atan(a / b):
        return a**2 * b - a**3 / (2*tan(th))
    else:
        return a * b**2 * tan(th) / 2


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

left = 0.0
right = pi/2
while right - left > error:
    mid = (left + right) / 2
    if calc(mid) <= x: #まだこぼれてない
        left = mid
    else: #こぼれ始めている
        right = mid

ans = (left + right) / 2
print(degrees(ans))

Submission status: Wrong Answer

Solution code:
from math import tan, atan, degrees, pi
error = 10**(-7)

def calc(th):
    if th > atan(a / b):
        return a**2 * b - a**3 / (2*tan(th))
    else:
        return a * b**2 * tan(th) / 2


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

left = 0.0
right = pi/2
while right - left > error:
    mid = (left + right) / 2
    if calc(mid) <= x: #まだこぼれてない
        left = mid
    else: #こぼれ始めている
        right = mid

ans = (left + right) / 2
print(degrees(ans))

Submission status: Wrong Answer

Solution code:
import math

a,b,x = map(int,input().split())
S = float(a * b * 0.5)

if S >= x:
  change_length = float(2*x/(a*b))
  rad = math.atan2(b, change_length)
else:
  change_length = float((2*b - 2*x/(a**2)))
  rad = math.atan2(change_length, a)
Theta = math.degrees(rad)
print('{:.10f}'.format(Theta))

Submission status: Wrong Answer

Solution code:
import math

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

if S >= x:
  #change_length = 2*x/((a**2)*b)
  rad = math.atan2(b, 2*x/(a*b))
  #rad = math.atan2(b, change_length)
else:
  #change_length = (2*b - 2*x/(a**2))
  #rad = math.atan2(change_length, a)
  rad = math.atan2((2*b - 2*x/(a**2)), a)
Theta = math.degrees(rad)
print('{:.10f}'.format(Theta))

Submission status: Wrong Answer

Solution code:
import math

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

if S >= x:
  change_length = 2*x/(a**2*b)
  rad = math.atan2(b, change_length)
else:
  change_length = (2*b - 2*x/a**2)
  rad = math.atan2(change_length, a)
Theta = math.degrees(rad)
print('{:.10f}'.format(Theta))

Submission status: Wrong Answer

Solution code:
import math

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

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

Submission status: Wrong Answer

Solution code:
import math
from decimal import Decimal
A, B ,X= map(int, input().split())
l=0
r=90
flag=0
pool=0

if X>=A*A*B/2:
    for i in range(100):
        k=math.tan(math.radians((r+l)/2))*A*A*A/2
        if A*A*B-k>=X:
            l=(r+l)/2
        else:
            r=(r+l)/2

        print(r)
else:
    for i in range(100):
        k = math.tan(math.radians(90-(r + l) / 2)) * B * B * A / 2
        if k>=X:
            l=(r+l)/2
        else:
            r=(r+l)/2
        print(r)

Submission status: Wrong Answer

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

side = x / a


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


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


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

Submission status: Wrong Answer

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

if x > a*b**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)

Submission status: Wrong Answer

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

if x > a*b**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(y/b)*180/math.pi)

Submission status: Wrong Answer

Solution code:
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**2*b/(2*x)))
print(ans)

Submission status: Wrong Answer

Solution code:
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(90)
else:
  print(90-math.degrees(math.atan(0.5*a**3/((b*a**2)-x))))

Submission status: Wrong Answer

Solution code:
import math
from decimal import Decimal
A, B ,X= map(int, input().split())
l=0
r=90
flag=0
pool=0

if X<A*A*B/2:
    X=A*A*B-X
    flag=1
for i in range(10000):
    k=math.tan(math.radians((r+l)/2))*A*A*A/2
    if A*A*B-k>=X:
        l=(r+l)/2
    else:
        r=(r+l)/2

    #print(l,r,k)
if flag==0:
    print(r)
else:
    print(90-r)

Submission status: Wrong Answer

Solution code:
import math
from decimal import Decimal
A, B ,X= map(int, input().split())
l=0
r=90
flag=0
pool=0

if X<A*A*B/2:
    X=A*A*B-X
    flag=1
for i in range(10000):
    k=math.tan(math.radians((r+l)/2))*A*A*A/2
    if A*A*B-k>=X:
        l=(r+l)/2
    else:
        r=(r+l)/2

    print(l,r,k)
if flag==0:
    print(r)
else:
    print(90-r)

Submission status: Wrong Answer

Solution code:
import math

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

Submission status: Wrong Answer

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

import math

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

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

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

Submission status: Wrong Answer

Solution code:
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
print(parcent)
if x/taiseki <= 0.5:
    menseki = mizu_height*a
    a = 2 * menseki / b
    #print(a)
    teihen = np.sqrt(a**2+b**2)
    #print(teihen)
    height = 2*menseki/teihen
    #print(height/b)
    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)))

Submission status: Wrong Answer

Solution code:
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
print(parcent)
if x/taiseki <= 0.5:
    menseki = mizu_height*a
    a = 2 * menseki / b
    #print(a)
    teihen = np.sqrt(a**2+b**2)
    #print(teihen)
    height = 2*menseki/teihen
    print(height/b)
    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)))

Submission status: Wrong Answer

Solution code:
import numpy as np
import math

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

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

    #print(np.arcsin(np.sin(b/height)))
    #print(90-np.sin(b/height))

else:
    pass

Submission status: Wrong Answer

Solution code:
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(a2/b)
  ans=r*(180/PI)
print(ans)

Submission status: Wrong Answer

Solution code:
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(math.degrees(math.atan(t))))

Submission status: Wrong Answer

Solution code:
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)) / 3.1415926535897932384626433832795028841971)
else:
  t_theta = (a*b*b) / (2*a)
  print ((180 * np.arctan(t_theta)) / 3.1415926535897932384626433832795028841971)

Submission status: Wrong Answer

Solution code:
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*a)
  print ((180 * np.arctan(t_theta)) / np.pi)

Submission status: Wrong Answer

Solution code:
import math

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

Submission status: Wrong Answer

Solution code:
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 = math.degrees(math.atan(n/height))
else:
  n = (2 * space) / (side * height)
  angle = math.degrees(math.atan(n/side))
print(angle)

Submission status: Wrong Answer

Solution code:
import math

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

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

    prizm_high = space / (side * side / 2)

    angle = math.degrees(math.atan(prizm_high/side))


    print(angle)

if __name__ == "__main__":
    main()

Submission status: Wrong Answer

Solution code:
import sys
import numpy as np
from numpy import linalg as LA

input = sys.stdin.readline

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

#a/2,x/a**2*b

u = np.array([a/2,0])
v = np.array([a/2,b-x/(a**2)])

i = np.inner(u, v)
n = LA.norm(u) * LA.norm(v)

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

print(ans)

Submission status: Wrong Answer

Solution code:
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)*180/pi)

Submission status: Wrong Answer

Solution code:
import math
def main():
    a,b,x = map(int,input().split())
    #print(a**2,b,x)
    d = (2 * x) / (a**2) - b
    #print(d)
    if d >=0:
        tan = (b - d) / a
    else:
        tan = a / (b + d)
    print(math.degrees(math.atan(tan)))
if __name__ == '__main__':
    main()

Submission status: Wrong Answer

Solution code:
import math
def main():
    a,b,x = map(int,input().split())
    #print(a**2,b,x)
    d = (2 * x) / (a**2) - b
    #print(d)
    tan = (b - d) / a
    print(math.degrees(math.atan(tan)))
if __name__ == '__main__':
    main()

Submission status: Wrong Answer

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

Submission status: Wrong Answer

Solution code:
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(b**2/(2*x))))
else:
  print(math.degrees(math.atan(c)))

Submission status: Wrong Answer

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

def test(theta):
   if theta < math.pi / 4:
       return (a * a * b) - (a * a * a * math.tan(theta) / 2)
   else:
       return a * b * b * math.tan(math.pi / 2 - theta) / 2



l = 0
r = math.pi / 2
mid = 0
for index in range(120):
    mid = (l + r) / 2
    # mid = index
    if test(mid) > x:
        l = mid
    else:
        r = mid

print('{:.10f}'.format(math.degrees(mid)))

Submission status: Wrong Answer

Solution code:
import math

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

zz = ((x * 2) / (a*a)) - b
r = math.degrees(math.atan((b - zz) / a))
print(r)

Submission status: Wrong Answer

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

def test(theta):
   if theta < math.pi / 4:
       return (a * a * b) - (a * a * a * math.tan(theta) / 2)
   else:
       return a * b * b * math.tan(math.pi / 2 - theta) / 2



l = 0
r = math.pi / 2
mid = 0
for index in range(120):
    mid = (l + r) / 2
    # mid = index
    if test(mid) > x:
        l = mid
    else:
        r = mid

print(math.degrees(mid))

Submission status: Wrong Answer

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

def test(theta):
   if theta < math.pi / 4:
       return (a * a * b) - (a * a * a * math.tan(theta) / 2)
   else:
       return a * b * b * math.tan(math.pi / 2 - theta) / 2



l = 0
r = math.pi / 2
mid = 0
for index in range(90):
    mid = (l + r) / 2
    # mid = index
    if test(mid) > x:
        l = mid
    else:
        r = mid

print(math.degrees(mid))

Submission status: Wrong Answer

Solution code:
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.acos(x/(a**2*b))))
else:
  print(math.degrees(math.atan(c)))

Submission status: Wrong Answer

Solution code:
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.acos(x/(a**2*b))))
else:
  print(math.degrees(math.acos(x/(a**2*b))))

Submission status: Wrong Answer

Solution code:
a,b,x = map(int, input().split())
m = a*b*b
r = 1 - x / m
print(r * 90)

Submission status: Wrong Answer

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

Submission status: Wrong Answer

Solution code:
import math
a,b,x = [int(x) for x in input().split()]
print(math.degrees(math.atan(b/a-x/a**3)))

Submission status: Wrong Answer

Solution code:
import math

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

Submission status: Wrong Answer

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

Submission status: Wrong Answer

Solution code:
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)

Submission status: Wrong Answer

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

Submission status: Wrong Answer

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

Submission status: Wrong Answer

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

Submission status: Wrong Answer

Solution code:
import math
import bisect
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]
    hs=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:
    print(0)

Submission status: Wrong Answer

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

if b == h:
    print(0)
    exit()

tanth = a / (b - h) / 2
theta = math.degrees(math.atan(tanth))

print(90 - theta)

Submission status: Wrong Answer

Solution code:
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)
else:
    print(0)

Submission status: Wrong Answer

Solution code:
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:
    print(1)
    y = 2*x/(a*b)
    print((math.degrees(math.atan2(b,y))))

Submission status: Wrong Answer

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

Submission status: Wrong Answer

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

Submission status: Wrong Answer

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

Submission status: Wrong Answer

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

Submission status: Wrong Answer

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

Submission status: Wrong Answer

Solution code:
import math

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

Submission status: Wrong Answer

Solution code:
import math

a,b,x = map(int,input().split())
if x > (a**1 * 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)))))

Submission status: Wrong Answer

Solution code:
import math

a,b,x = map(int,input().split())
if x >= (a**1 * 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)))))

Submission status: Wrong Answer

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

Submission status: Wrong Answer

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

s = x / a
height = s / a
print(a,b,x)

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

Submission status: Wrong Answer

Solution code:
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))
print(deg)

Submission status: Wrong Answer

Solution code:
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 / (a**3)
    z = math.atan(c*2)
    print(z)
elif x == v:
    z = math.atan(1)
    print(z)
else:
    c = (a*(b**2)) / (x*2)
    z = math.atan(c)
    print(z)

Submission status: Wrong Answer

Solution code:
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 / (a**3)
    z = math.atan(c*3)
    print(z)
elif x == v:
    z = math.atan(1)
    print(z)
else:
    c = (a*(b**2)) / (x*3)
    z = math.atan(c)
    print(z)

Submission status: Wrong Answer

Solution code:
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 / (a**3)
    z = math.atan(c)
    print(z)
elif x == v:
    z = math.atan(1)
    print(z)
else:
    c = (a*(b**2)) / x
    z = math.atan(c)
    print(z)

Submission status: Wrong Answer

Solution code:
# ABC144D - Water Bottle
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 - (A ** 2 * X))
        ans = degrees(atan(C / A))
    print(ans)


if __name__ == "__main__":
    main()

Submission status: Wrong Answer

Solution code:
from math import atan,atan2,degrees

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

# 半分より多いとき
if a * a * b / 2 < x:
  print(90-degrees(atan(2*b/a -2*x/(a*a*a))))
else:
  # 半分より少ないとき
  print(90-degrees(atan(2*x/(a*b*b))))

Submission status: Wrong Answer

Solution code:
from enum import Enum
from queue import Queue

import numpy as np

import collections
import bisect
import sys
import math

from scipy.sparse.csgraph import floyd_warshall

BIG_NUM = 200000000000
MOD = 1000000007
EPS = 0.000000001
a,b,x = map(int,input().split())

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

Submission status: Wrong Answer

Solution code:
import math
def f(a,b,x):
    tan = a/(2*(a^2*b-x))
    print(str(math.degrees(math.atan(tan))))

s = input().split()
s2= list(map(int,s))
f(*s2)

Submission status: Wrong Answer

Solution code:
import math
def f(a,b,x):
    tan = a/(2*(a^2*b-x))
    print(str(90-math.degrees(math.atan(tan))))

s = input().split()
s2= list(map(int,s))
f(*s2)

Submission status: Wrong Answer

Solution code:
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 = atan(v / 2 / x)
    t = pi / 2 - atan(2 * x / v)

print(t * 180.0 / pi)

Submission status: Wrong Answer

Solution code:
from math import atan, pi

eps = 10e-8

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

v = a * a * b

if v / 2 < x - eps:
    t = atan(2 * (v - x) / (a * a * a))
elif v / 2 > x + eps:
    # t = atan(v / 2 / x)
    t = pi / 2 - atan(2 * x / v)
else:
    t = atan(b / a)

print(t * 180.0 / pi)

Submission status: Wrong Answer

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

Submission status: Wrong Answer

Solution code:
from math import atan, pi

eps = 10e-8

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

v = a * a * b

if v / 2 < x - eps:
    t = atan(2 * (v - x) / (a * a * a))
elif v / 2 > x + eps:
    t = atan(v / 2 / x)
else:
    t = atan(b / a)

print(t * 180.0 / pi)

Submission status: Wrong Answer

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

if x / (b * a**2 ) < 1/2:
    x2 = (2*a) / (b*x)
    y2 = b
else:
    x2 = a
    y2 = 2 * (b-(x / a ** 2))
print(degrees(atan2(y2, x2)))

Submission status: Wrong Answer

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

Submission status: Wrong Answer

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

def capa(theta):
    theta = theta*math.pi/180
    if math.tan(theta) >= b/a:
        return a*a*(b - a*math.tan(theta)/2)
    else:
        return a*b*b/(2*math.tan(theta))

left = 0
right = 90
while right - left > 10**(- 7):
    mid = (left + right)/2
    if capa(mid) > x:
        left = mid
    else:
        right = mid
print((left + right)/2)

Submission status: Wrong Answer

Solution code:
import math
a,b,x = map(int, input().split())
def f(a,b,t):
  if t < math.atan(a/b): return a*a*b - a*a*a*math.tan(t)/2
  elif t > math.atan(a/b): return a*b*b*math.tan(math.pi/2-t)/2
  else: return a*a*b/2
  
th = [math.atan(a/b), 0, math.pi/2]
err = float("inf")
eps = 1e-3
while abs(err) > eps:
  err = x - f(a,b,th[0])
  if abs(err) < eps: break
  elif err < 0:
    th[0], th[1] = (th[2]-th[0])/2+th[0], th[0]
  elif err > 0:
    th[0], th[2] = (th[0]-th[1])/2+th[1], th[0]
    
  #print(err, th)
print(math.degrees(th[0]))

Submission status: Wrong Answer

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

Submission status: Wrong Answer

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

Submission status: Wrong Answer

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

Submission status: Wrong Answer

Solution code:
import math
a, b, x = map(int, input().split())
if x <= a*a*b/2:
    low, high = 45.0, 90.0
    while high - low > 0.0000000000001:
        key = (low+high)/2
        if math.tan(math.radians(90-key))*b*b*a/2 > x:
            low = key
        else:
            high = key
    print(key)
else:
    v = a*a*b
    low, high = 0.0, 45.0
    while high - low > 0.0000000000001:
        key = (low+high)/2
        if v - math.tan(math.radians(key))*a*a*a/2 > x:
            low = key
        else:
            high = key
    print(key)

Submission status: Wrong Answer

Solution code:
import math
a, b, x = map(int, input().split())
if x <= a*a*b/2:
    low, high = 45.0, 90.0
    while high - low > 0.0000000001:
        key = (low+high)/2
        if math.tan(math.radians(90-key))*b*b*a/2 > x:
            low = key
        else:
            high = key
    print(key)
else:
    v = a*a*b
    low, high = 0.0, 45.0
    while high - low > 0.0000000001:
        key = (low+high)/2
        if v - math.tan(math.radians(key))*a*a*a/2 > x:
            low = key
        else:
            high = key
    print(key)

Submission status: Wrong Answer

Solution code:
import math
a, b, x = map(int, input().split())
if x <= a*a*b/2:
    low, high = 45.0, 90.0
    while high - low > 0.0000000001:
        key = (low+high)/2
        if math.tan(math.radians(90-key))*b*b*a/2 > x:
            low = key
        else:
            high = key
    print(low)
else:
    v = a*a*b
    low, high = 0.0, 45.0
    while high - low > 0.0000000001:
        key = (low+high)/2
        if v - math.tan(math.radians(key))*a*a*a/2 > x:
            low = key
        else:
            high = key
    print(low)

Submission status: Wrong Answer

Solution code:
import math
a, b, x = map(int, input().split())
if x <= a*a*b/2:
    low, high = 45.0, 90.0
    while high - low > 0.00000001:
        key = (low+high)/2
        if math.tan(math.radians(90-key))*b*b*a/2 > x:
            low = key
        else:
            high = key
    print(low)
else:
    v = a*a*b
    low, high = 0.0, 45.0
    while high - low > 0.00000001:
        key = (low+high)/2
        if v - math.tan(math.radians(key))*a*a*a/2 > x:
            low = key
        else:
            high = key
    print(low)

Submission status: Wrong Answer

Solution code:
"""
制約
a,b,xはすべて整数
1≦a≦100
1≦b≦100
1≦x≦a^2b

mathライブラリ
tanから角度を求めるとき(math.atan())と
弧度を度数に変換するとき(math.degrees())を用いる。
"""
import math

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

#計算&出力
if a * a * b > 2 * x:
  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:
import sys
import math
import bisect
 
 
sys.setrecursionlimit(1000000000)
def input():
    return sys.stdin.readline().strip()
 
def iinput():
    return int(input())
 
def finput():
    return float(input())
 
def tinput():
    return input().split()
 
def rinput():
    return map(int, tinput())
 
def rlinput():
    return list(rinput())
 
def modst(a, s):
    res = 1
    while s:
        if s % 2:
            res *= a
        a *= a
        s //= 2
    return res

 
def main():
    a, b, x = rinput()
    p = math.pi
    if x >= 2 *  a * a * b:
        print(180 * math.atan((2 * b - x * 2 / a / a ) / a) / p)
    else:
        print(180 / p * math.atan(b / x * a * b / 2))
main()

Submission status: Wrong Answer

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

Submission status: Wrong Answer

Solution code:
# ABC144d


def main():
    import sys
    import math
    import numpy as np
    input = sys.stdin.readline
    sys.setrecursionlimit(10**6)

    a, b, x = map(int, input().split())
    if x > a*b*b/2:
        print(np.rad2deg(np.arctan(2*(a*a*b-x)/(a*a*a))))
        # print(math.degrees(math.atan(2*(a*a*b-x)/(a*a*a))))
        exit(0)
    # print(math.degrees(math.atan(a*b*b/2/x)))
    print(np.rad2deg(np.arctan(a*b*b/2/x)))


if __name__ == '__main__':
    main()

Submission status: Wrong Answer

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

Submission status: Wrong Answer

Solution code:
# ABC144d


def main():
    import sys
    import math
    input = sys.stdin.readline
    sys.setrecursionlimit(10**6)

    a, b, x = map(int, input().split())
    if a*b*b/2 < x:
        print(math.degrees(math.atan(2*(a*a*b-x)/(a*a*a))))
        exit(0)
    print(math.degrees(math.atan(a*b*b/2/x)))


if __name__ == '__main__':
    main()

Submission status: Wrong Answer

Solution code:
# ABC144d


def main():
    import sys
    import math
    input = sys.stdin.readline
    sys.setrecursionlimit(10**6)

    a, b, x = map(int, input().split())
    if a*b*b/2 < x:
        print(math.degrees(math.atan((a*a*b-x)/a/a/a*2)))
        exit(0)
    print(math.degrees(math.atan(b*b*a/2/x)))


if __name__ == '__main__':
    main()