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

Submission status: Wrong Answer

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

Submission status: Wrong Answer

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


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

Submission status: Wrong Answer

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

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

Submission status: Wrong Answer

Solution code:
import math 

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

Submission status: Wrong Answer

Solution code:
import math 

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

Submission status: Wrong Answer

Solution code:
import math 

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

Submission status: Wrong Answer

Solution code:
import math 

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

Submission status: Wrong Answer

Solution code:
import math 

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

Submission status: Wrong Answer

Solution code:
import math 

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

Submission status: Wrong Answer

Solution code:
import math 

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

Submission status: Wrong Answer

Solution code:
import math
l , h , V = map(int,input().split())

h_0 = V / (l * l)
print(h_0)

Submission status: Wrong Answer

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

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

Submission status: Wrong Answer

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

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

Submission status: Wrong Answer

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

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

Submission status: Wrong Answer

Solution code:
import math

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

def main(a,b,x):
    if ((a**2*b)-x) != 0:
        y = (a ** 3)/(2*((a**2*b)-x))
        θ = math.atan(y)
        result = math.degrees(math.pi/2-θ)
        return result
    else:
        return 0

print(main(a,b,x))

Submission status: Wrong Answer

Solution code:
import math

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

def main(a,b,x):
    if ((a**2*b)-x) != 0:
        y = (a ** 3)/(2*((a**2*b)-x))
        θ = math.atan(y)
        result = math.degrees(θ)
        return 90-result
    else:
        return 0

print(main(a,b,x))

Submission status: Wrong Answer

Solution code:
import math

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

def main(a,b,x):
    if ((a**2*b)-x) != 0:
        y = (a ** 3)/(2*((a**2*b)-x))
        θ = math.atan(y)
        result = math.degrees(θ)
        return 90-result
    else:
        return 0

print(main(a,b,x))

Submission status: Wrong Answer

Solution code:
# 2019-11-19 19:43:48(JST)
import sys
# import collections
from math import atan, pi
# from string import ascii_lowercase, ascii_uppercase, digits
# from bisect import bisect_left as bi_l, bisect_right as bi_r
# import itertools
# from functools import reduce
# import operator as op
# import re
# import heapq
# import array
# from scipy.misc import comb # (default: exact=False)
# import numpy as np 


def main():
    a, b, v = map(int, sys.stdin.readline().split())

    if v / a >= a * b / 2:
        ans = atan(2 * (b - v / a ** 2) / a) * 180 / pi 
    else:
        ans = atan(a ** 2 * b / (2 * v)) * 180 / pi
    
    print(ans)

if __name__ == "__main__":
    main()

Submission status: Wrong Answer

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

Submission status: Wrong Answer

Solution code:
from math import pi, atan, degrees

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

Submission status: Wrong Answer

Solution code:
import math
a,b,x=map(int,input().split())
#辺cを求める
c=2*(a*a*b-x)/(a*a)
print(math.degrees(math.atan(c/a)))

Submission status: Wrong Answer

Solution code:
import math

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

tmp = a*a*b/2

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

Submission status: Wrong Answer

Solution code:
import math

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

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

Submission status: Wrong Answer

Solution code:
import math

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

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

Submission status: Wrong Answer

Solution code:
import math

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

taiseki = a * a * b
print(taiseki)
print(x)

if taiseki - x < x:
    takasa = (taiseki - x) * 2 / (a * a)
    # print(takasa)
    print(math.degrees(math.atan(takasa/a)))
else:
    takasa = x * 2 / (a * b)
    # print(takasa)
    print(math.degrees(math.atan(b/takasa)))

Submission status: Wrong Answer

Solution code:
import math

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

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

print(ans)

Submission status: Wrong Answer

Solution code:
import math

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

print(ans)

Submission status: Wrong Answer

Solution code:
import math

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

Submission status: Wrong Answer

Solution code:
import math as m
a,b,x= map(int,input().split())
h = x/(a**2)
if h == b:
    theta = 0
elif h > b/2:
    theta = m.degrees(m.atan((2*a*b-2*x)/a**3))
elif h < b/2:
    theta = m.degrees(m.atan(a*b**2/(2*x)))
else:
    theta = m.degrees(m.atan(b/a))
    
print(theta)

Submission status: Wrong Answer

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

base = a ** 2
Remaining_area = (base * b) - x
l = Remaining_area / a ** 2
angle_1 = 90 / b
angle = l / angle_1

print(angle)

Submission status: Wrong Answer

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

base = a ** 2
Remaining_area = (base * b) - x
l = Remaining_area / a ** 2
angle = l / (b / 90)

print(angle)

Submission status: Wrong Answer

Solution code:
import math
a, b, x = map(int, input().split())
h=x/(a**2)
if h>b/2:
    y=2*a*h/b
    shita=math.degrees(math.atan2(y,b))
if h<=b/2:
    y=2*h-b
    y=b-y
    shita=math.degrees(math.atan2(b,y))
print(shita)

Submission status: Wrong Answer

Solution code:
import math
input01 = input()
a=input01.split()

tate=float(a[0])
takasa=float(a[1])
mizu=float(a[2])
menseki1 = tate * takasa
menseki2 = mizu / tate
diff=menseki1-menseki2
rad=0
if(diff <= tate*takasa/2):
    stakasa=2*diff/(tate)
    rad = math.degrees(math.atan(stakasa/tate))
elif(diff > tate*takasa/2):
    stakasa=2*(tate*takasa-diff)/(tate)
    rad = math.degrees(math.atan(tate/stakasa
                                 )) 
    

print(rad)

Submission status: Wrong Answer

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

Submission status: Wrong Answer

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



theta = math.degrees(math.atan(b*b*a/(2*x)))
if a*a*b <=  x-1e-9:
    print(1e-7)
elif a*a*b/2 >= x:
    print(theta)
else:
    L = 1e-6
    R = theta
    while R-L > 1e-7:
        theta = (R+L)/2
        beta = math.degrees(math.atan(b/a))
        alpha = beta-theta
        xp = a*(a*a+b*b)*math.sin(math.radians(alpha))*math.cos(math.radians(alpha))/2 - a*(a*a+b*b)*math.sin(math.radians(alpha))*math.sin(math.radians(alpha))/(2*math.tan(math.radians(90-beta+alpha)))  + a*a*b/2
        if x< xp:
            L = theta
        else:
            R = theta

    print(R)

Submission status: Wrong Answer

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



theta = math.degrees(math.atan(b*b*a/(2*x)))
if a*a*b <=  x-1e-9:
    print(0)
elif a*a*b/2 >= x:
    print(theta)
else:
    L = 1e-6
    R = theta
    while R-L > 1e-7:
        theta = (R+L)/2
        beta = math.degrees(math.atan(b/a))
        alpha = beta-theta
        xp = a*(a*a+b*b)*math.sin(math.radians(alpha))*math.cos(math.radians(alpha))/2 - a*(a*a+b*b)*math.sin(math.radians(alpha))*math.sin(math.radians(alpha))/(2*math.tan(math.radians(90-beta+alpha)))  + a*a*b/2
        if x< xp:
            L = theta
        else:
            R = theta

    print(R)

Submission status: Wrong Answer

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



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

if a*a*b/2 >= x:
    print(theta)
else:
    L = 1e-6
    R = theta
    while R-L > 1e-7:
        theta = (R+L)/2
        beta = math.degrees(math.atan(b/a))
        alpha = beta-theta
        xp = a*(a*a+b*b)*math.sin(math.radians(alpha))*math.cos(math.radians(alpha))/2 - a*(a*a+b*b)*math.sin(math.radians(alpha))*math.sin(math.radians(alpha))/(2*math.tan(math.radians(90-beta+alpha)))  + a*a*b/2
        if x< xp:
            L = theta
        else:
            R = theta

    print(R)

Submission status: Wrong Answer

Solution code:
import sys
import math

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

T=a*(b-(x/(a*a)))

c=2*T/a

d = math.atan2(c, a)
d_deg=math.degrees(d)

#print(d)
print(d_deg)

Submission status: Wrong Answer

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

Submission status: Wrong Answer

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

Submission status: Wrong Answer

Solution code:
import math

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

h = x/(a**2)

if (a**2)* b / 2.0 > x:
    print('over')
    v = (a**2)*(b-h)*2 / (a**2)
    theta = 90 - math.atan(a/v)
    print(theta)
else:
    print('under')
    w = 2*x/(a*b)
    theta = 90 - math.atan(w/b)
    print(theta)

Submission status: Wrong Answer

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

Submission status: Wrong Answer

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

Submission status: Wrong Answer

Solution code:
import math
a,b,x=map(int,input().split())
if x>=2/a**2*b:
  b_=2*(a**2*b-x)/a**2
  theta=math.acos(a/((b_)**2+a**2)**0.5)
  print(math.degrees(theta))
else:
  a_=2*x/a*b
  th=math.acos(a_/((a_)**2+b**2)**0.5)
  print(math.degrees(th))

Submission status: Wrong Answer

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

Submission status: Wrong Answer

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

Submission status: Wrong Answer

Solution code:
import math

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

Submission status: Wrong Answer

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

Submission status: Wrong Answer

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

Submission status: Wrong Answer

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

Submission status: Wrong Answer

Solution code:
import math

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

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

Submission status: Wrong Answer

Solution code:
import math

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

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

Submission status: Wrong Answer

Solution code:
import math

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

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

Submission status: Wrong Answer

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

Submission status: Wrong Answer

Solution code:
# # 整数の入力
# a = int(input())
# # スペース区切りの整数の入力
# b, c = map(int, input().split())
# # 文字列の入力
# s = input()
import math
a, b, x = map(int, input().split())
x /= a
ans = math.degrees(math.atan(x * 2 / b / b))
print(90 - ans)

Submission status: Wrong Answer

Solution code:
# # 整数の入力
# a = int(input())
# # スペース区切りの整数の入力
# b, c = map(int, input().split())
# # 文字列の入力
# s = input()
import math
a, b, x = map(int, input().split())
x /= a

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

Submission status: Wrong Answer

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

def xx(y):
  aHeight = a*math.sin(y)
  bHeight = b*math.sin(0.5*math.pi-y)
  if aHeight < bHeight:
    menseki = 0.5*a*b + (bHeight/aHeight*a-b)*math.sin(0.5*math.pi-y)*(a/math.cos(y))
  else:
    aD = bHeight/math.sin(y)
    menseki = 0.5*aD*b
  return menseki

minY = 0
maxY = 0.5*math.pi
counter = 0
while True:
  menseki = xx((minY+maxY)/2)
  if menseki - x/a < 1 or counter > 10000:
    print((minY+maxY)/2 * (180/math.pi))
    break
  elif menseki < x/a:
    maxY = (minY+maxY)/2
  else:
    minY = (minY+maxY)/2

Submission status: Wrong Answer

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

def xx(y):
  aHeight = a*math.sin(y)
  bHeight = b*math.sin(0.5*math.pi-y)
  if aHeight < bHeight:
    menseki = 0.5*a*b + (bHeight/aHeight*a-b)*math.sin(0.5*math.pi-y)*(a/math.cos(y))
  else:
    aD = bHeight/math.sin(y)
    menseki = 0.5*aD*b
  return menseki

minY = 0
maxY = 0.5*math.pi
while True:
  menseki = xx((minY+maxY)/2)
  if abs(x/a - menseki) < 0.1:
    print((minY+maxY)/2 * (180/math.pi))
    break
  elif menseki < x/a:
    maxY = (minY+maxY)/2
  else:
    minY = (minY+maxY)/2

Submission status: Wrong Answer

Solution code:
import math

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

def over_flag(a,b,x):
    return math.atan( 2*b/a-2*x/a**3 )*180/math.pi
 
def below_flag(a,b,x):
    return 90-math.atan(2*x/(a*b**2))/math.pi*180

def main(a,b,x):
    if x>a**2*b:
        print(0)
        return 0
    if x>a**2*b/3:
        print(over_flag(a,b,x))
    else:
        print(below_flag(a,b,x))
    return 0
main(a,b,x)

Submission status: Wrong Answer

Solution code:
import math

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

def over_flag(a,b,x):
    return math.atan( b/a-(3*x-a**2*b)/a**3 )*180/math.pi
 
def below_flag(a,b,x):
    return 90-math.atan(3*x/(a*b**2))/math.pi*180

def main(a,b,x):
    if x>a**2*b:
        print(0)
        return 0
    if x>a**2*b/3:
        print(a**2*b/3)
        print(over_flag(a,b,x))
    else:
        print(below_flag(a,b,x))
    return 0
main(a,b,x)

Submission status: Wrong Answer

Solution code:
import math

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

def over_flag(a,b,x):
    return math.atan( b/a-(3*x-a**2*b)/a**3 )*180/math.pi
 
def below_flag(a,b,x):
    return 90-math.atan(3*x/a*b*b)/math.pi*180

def main(a,b,x):
    if x>a**2*b:
        print(0)
        return 0
    if x>1/3*a**2*b:
        print(over_flag(a,b,x))
    else:
        print(below_flag(a,b,x))
    return 0
main(a,b,x)

Submission status: Wrong Answer

Solution code:
import math

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

def over_flag(a,b,x):
    return math.atan( (3/2*b-3*x)/a )*180/math.pi
 
def below_flag(a,b,x):
    return (0.5-math.atan(3*x/a*b*b)/math.pi)*180

def main(a,b,x):
    if x>a**2*b:
        print(0)
        return 0
    if x>1/6*a**2*b:
        print(over_flag(a,b,x))
    else:
        print(below_flag(a,b,x))
    return 0
main(a,b,x)

Submission status: Wrong Answer

Solution code:
import math

a,b,l=tuple(map(int,input().split()))

x=2*a*a*b - 2*l

y=x/(a*a*a)

print("%.10f"%math.degrees(math.atan(y)))

Submission status: Wrong Answer

Solution code:
import math

def process(a,b,x):
    S =  (a * b) / 2
    if x > S:
        m = ((2 * x) / a**2) - b
        return (b - m) / a
        return
    elif x < S:
        m = (2 * x) / (a*b)
        return b / m
        pass
    else:
        return b/a


arr = input().split(' ')

A = int(arr[0])
B = int(arr[1])
X = int(arr[2])

result = process(A,B,X)

print(math.degrees(math.atan(result)))

Submission status: Wrong Answer

Solution code:
import math
a, b, x = map(int, input().split())
if x >= a*a*b/2:
   print(math.degrees(math.atan(2/a*(b-x/(a*a)))))
else:
   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 x >= a*a*b/2:
   print(math.degrees(math.tanh(2/a*(b-x/(a*a)))))
else:
   print(90-math.degrees(math.tanh(2*x/(a*b*b))))

Submission status: Wrong Answer

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

Submission status: Wrong Answer

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

Submission status: Wrong Answer

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

Submission status: Wrong Answer

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

Submission status: Wrong Answer

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

Submission status: Wrong Answer

Solution code:
import math

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

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

Submission status: Wrong Answer

Solution code:
import math

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

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

Submission status: Wrong Answer

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

Submission status: Wrong Answer

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

d = b - v/(a**2)
if d < b-d or 1==1:
  h = (b-d)*2
  l = math.sqrt(a**2 + h**2)
  x = math.degrees(math.atan(h/a))
  print(x)
  #a**2 - h**2 - l**2 =- 2ab cosA
else:
  print(10000)

Submission status: Wrong Answer

Solution code:
import math
N=list(map(int,input().split()))



if N[2]<=N[0]**2*N[1]/2:   
 a=N[1]
 b=N[2]/N[0]/N[1]*2
 print(90-math.degrees(math.atan(b/a)))
else: 
 c=N[0]**2*N[1]-N[2]
 a=N[1]
 b=c/N[0]/N[0]*2
 print(b)
 print(math.degrees(math.atan(b/N[0])))

Submission status: Wrong Answer

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

if x > a**2*b/2:
    print(degrees(np.arctan(2*x/a**3)))
else:
    print(90-degrees(np.arctan(2*x/(a*b**2))))

Submission status: Wrong Answer

Solution code:
import numpy as np

f = lambda a, b, x: np.rad2deg(np.arctan((a**2*b-x)*2/a**3))

x = map(int, input().split())
print(f(*x))

Submission status: Wrong Answer

Solution code:
import numpy as np

f = lambda a, b, x: np.rad2deg(np.arctan((a**2*b-x)*2)/a**3)

x = map(int, input().split())
print(f(*x))

Submission status: Wrong Answer

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

Submission status: Wrong Answer

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

Submission status: Wrong Answer

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

Submission status: Wrong Answer

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

Submission status: Wrong Answer

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

Submission status: Wrong Answer

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

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

Submission status: Wrong Answer

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

h = x / a / a
t = (b - h) / a * 2
if t > 1:
  t = b / x * b * a / 2
print (math.degrees(math.atan(t)))

Submission status: Wrong Answer

Solution code:
import math

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

if x > a * a * b * 0.5:
	c = 2 * b - 2 * x / ( a * a )
	degree = math.degrees(math.atan2(c,a))

else:
	c = 2 * x / (a * b)
	degree = math.degrees(math.atan2(c,b))

print(degree)

Submission status: Wrong Answer

Solution code:
import math
a,b,x=map(int,input().split())
if a*b/2<=x:
    print(math.degrees(math.atan(2*(a**2*b-x)/a**3)))
else:
    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())
if a*b/2<=x:
    print(math.degrees(math.atan(2*(b-x/(a**2))/a)))
else:
    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())
if a*b/2<x:
    print(math.degrees(math.atan(2*(b-x/(a**2))/a)))
else:
    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())
if 2*x<=a*a*b:
    y = math.degrees(math.atan( 2*b/a-2*x/a**3 ))
else:
    y = math.degrees(math.atan( a*b**2/(2*x) ))
print(y)

Submission status: Wrong Answer

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

ans = math.degrees(y)
print(ans)

Submission status: Wrong Answer

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

Submission status: Wrong Answer

Solution code:
import math


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


if x/a >= b*a/2:

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

else:
    
    y= 2*x/(a*a)

    print(math.degrees(math.atan(a/y)))

Submission status: Wrong Answer

Solution code:
import math

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


if x/a >= b*a/2:

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

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

Submission status: Wrong Answer

Solution code:
import math

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

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

print(math.degrees(math.atan(num)))

Submission status: Wrong Answer

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

h = ((x/a)/b)*2
w = b
r = math.sqrt(h*h + w*w)

theta = math.atan2(w,h)
print(math.degrees(theta))

Submission status: Wrong Answer

Solution code:
import math

a,b,x = [int(i) for i in input().split()]
c = 2 * x / a ** a - b
she = math.degrees(math.atan2(b-c,a))
print(she)

Submission status: Wrong Answer

Solution code:
#!/usr/bin/env python3
import math


def main():
    a, b, x = input_line(int, int, int)
    if a ** 2 * b / 2 < x:
        tt = 2 / a ** 3
    else:
        tt = a * b ** 2 / (2 * x)
    t = math.degrees(math.atan(tt))
    print(t)


def input_line(*types):
    if len(types) == 1:
        return types[0](input())
    else:
        return [t(x) for t, x in zip(types, input().split())]


if __name__ == "__main__":
    main()

Submission status: Wrong Answer

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

Submission status: Wrong Answer

Solution code:
import math
a,b,x=map(int,input().split())
A=a*a
R=A*b
s=R-x
l=0
r=90
while r-l>1e-6:
    m=(r+l)/2
    if s> math.tan(90-m)*a*A/3:
        l=m
    else:
        r=m

print(m)

Submission status: Wrong Answer

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

def ok(mid,a,b,x_s):
    x = a * math.sin(mid*math.pi/180)/math.sin(math.pi/2 - (mid * math.pi/180))
    s = 0
    if b - x > 0:
        s = (b + x)/2 * a
    else:
        x = b * math.sin(math.pi/2 - (mid * math.pi/180))/math.sin(mid*math.pi/180)
        s = 0.5 * x * b
    if s < x_s:
        return -1
    else:
        return 1

def bin_search(a,b,x):
    l = 0.0
    r = 90.0
    while abs(l - r) > 1e-7:
        mid = l + (r - l)/2
        res = ok(mid,a,b,x)
        if res < 0:
            r = mid
        else:
            l = mid
    return r


print(bin_search(a,b,x/a))

Submission status: Wrong Answer

Solution code:
import math

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

a = int(a)
b = int(b)
x = int(x)

h = x/(a**2)
#w = math.sqrt(abs(b**2-h**2))
#print('h: ', h, ', w:', w)

print(math.degrees( math.atan2(b-h, a/2) ))

Submission status: Wrong Answer

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

Submission status: Wrong Answer

Solution code:
import os
import numpy as np

class getStdin(object):
    @classmethod
    def get_int(cls):
        return int(input())

    @classmethod
    def get_ss_int(cls):
        return list(map(float, input().split()))

    @classmethod
    def get_na_int(cls):
        return np.array(sorted(list(map(int, input().split()))))

    @classmethod
    def get_na_intr(cls):
        return np.array(sorted(list(map(int, input().split())))[::-1])


class funcCls(object):
    @classmethod
    def done(cls, a, b, x):
        import math
        mm = x / a
        if x <= (a * b / 2):
            th = math.degrees(math.atan(b ** 2 / (2 * mm)))
        else:
            th = math.degrees(math.atan((-2*mm + 2*a*b) / a ** 2))

        return th


if __name__ == '__main__':
    a, b, x = getStdin.get_ss_int()
    y = funcCls.done(a, b, x)

    print(y)
    os.sys.exit(0)

Submission status: Wrong Answer

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

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) / math.pi * 180 > 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)