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


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

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


if __name__ == '__main__':
    main()

Submission status: Wrong Answer

Solution code:
import math
a, b, x = map(int, input().split())
m = a*a*b
aa = b-x / (a*a)
# bb = x / (a*b)
if aa < b//2:
    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:
import math

a, b, x = map(int, input().split())
p = x / (a * a * b)
print(math.degrees(math.atan(90*(1-p))))

Submission status: Wrong Answer

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

def waterbottle(a,b,x):
    if 2*a*a*b-2*x == 0:
        theta2 = math.atan(2*x/(a*b*b))
        return 90 - math.degrees(theta2)

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

    if a < math.tan(theta)*b:
        result = 90 - math.degrees(theta)
    else:
        result = 90 - math.degrees(theta2)
    return result
print(waterbottle(a,b,x))

Submission status: Wrong Answer

Solution code:
import math


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

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


if __name__ == '__main__':
    main()

Submission status: Wrong Answer

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

Submission status: Wrong Answer

Solution code:
import numpy as np
import math
a,b,x=np.array(list(map(int, input().split())))
if x>=a*b/2:
    print('{:.10f}'.format(math.degrees(math.atan2(2*b-2*x/a**2,a))))
else:
    print('{:.10f}'.format(math.degrees(math.atan2(b,2*x/(a*b)))))

Submission status: Wrong Answer

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

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

Submission status: Wrong Answer

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

Submission status: Wrong Answer

Solution code:
import numpy as np

a, b, x = map(int,input().split())
c = b-(x/a**2)
d = a*b

if c <= b//2:
    print(np.degrees(np.arctan2(b-(x / a**2),a/2)))

else:
    print(np.degrees(np.arctan2(b,(x/d))))

Submission status: Wrong Answer

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

Submission status: Wrong Answer

Solution code:
import math
a, b, V = [int(s) for s in input().split()]

def judge(theta, a, b, V):
  theta_rad = math.radians(theta)
  tan = math.tan(theta_rad)
  y = (V - a**3*tan/2)/a**2
  if y >= 0.:
    if y+a*tan <= b:
      return True
    else:
      return False
  else:
    z = math.sqrt(V/tan/a*2)
    if z*tan <= b:
      return True
    else:
      return False

theta_eval = [0., 89.9999999999]

while theta_eval[1]-theta_eval[0] >= 1e-7:
  delta = 1.0
  while judge(theta_eval[0]+delta, a, b, V) == False:
    delta = delta/2
  theta_eval[0] += delta
  delta = 1.0
  while judge(theta_eval[1]-delta, a, b, V) == True:
    delta = delta/2
  theta_eval[1] -= delta

print(theta_eval[0])

Submission status: Wrong Answer

Solution code:
import math
a, b, x = map(int, input().split())
m = a*a*b
aa = b-x / (a*a)
bb = x / (a*b)
if aa > bb:
    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:
import math
a,b,x=map(int,input().split())
L=0
R=90
C=45
D=0
div=b/a
x=round(x,10)
while True:
    if D==C:
        break
    if C<=div:
        tanC=math.tan(math.radians(C))
        tanC=round(tanC,10)
        hh=(2*b-a*tanC)*a/2*a
    if C>div:
        tanC=math.tan(math.radians(C))
        tanC=round(tanC,10)
        hh=b/tanC*b/2*a
    if hh==x:
        break
    D=C
    if hh>x:
        L=C
        C=round((R+C)/2,10)
    if hh<x:
        R=C
        C=round((L+C)/2,10)
        
print("{0:.10f}".format(C))

Submission status: Wrong Answer

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

Submission status: Wrong Answer

Solution code:
import math

a,b,x = map(int,input().split())
n_height = float(x)/float(a)/float(a)
sub_height = b-n_height

if (float(n_height)/(float(b) >= 0.5)):
    k=math.degrees(math.atan((2*sub_height)/a))
else:
    print(math.degrees(math.atan((2*x/a)/(b*b))))

Submission status: Wrong Answer

Solution code:
# D - Water Bottle
import math
a,b,x = map(int, input().split())

tmp = x/(a**2)
# tmp2 = x/(b**2)
tmp2 = (2*x/b)**(1/2)

if tmp2 < a:
    print(90-math.degrees(math.atan2(a,tmp2)))
else:
    #print(tmp)
    tmp3 = (2*b-((2*x)/(a*a)))
    #print(tmp3)
    print(90-math.degrees(math.atan2(a,tmp2)))

Submission status: Wrong Answer

Solution code:
import math

class _const:
    def __init__(self):
        self.PI=math.acos(-1)
        self.convToDEG=180/self.PI
const=_const()


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

Volume=a*a*b

if 2*x>=Volume:
    print(const.convToDEG*math.atan(2*(a*a*b-x)/a**3))

else:
    h=2*x/(a*b)
    r=h/b
    if(0<=r and r<=1):
        print(const.convToDEG*math.acos(r))
    elif r>1:
        print("90")
    else:
        print("0")

Submission status: Wrong Answer

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

Submission status: Wrong Answer

Solution code:
import math

if __name__ == "__main__":
    a, b, x = map(float, input().split(" "))
    # 底面の1辺 = a
    # 高さ = b
    # 水の体積 = x
    if x > a**2 * b / 2.0:
        tanT = (2.0*b - 2.0*x/a**2) / a
        T = math.atan(tanT)
        print(math.degrees(T))
    else:
        tanT = 2.0 * x / (a * b**2)
        T = math.atan(tanT)
        print(math.degrees(T))

Submission status: Wrong Answer

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

Submission status: Wrong Answer

Solution code:
import math


def calc1():
    if x >= V_div2:
        r = math.degrees(math.atan(2 * (V - x) / (a * a * a)))
        print(r)
    else:
        r = math.degrees(math.atan((a * b * b) / (2 * x)))
        # r = math.degrees(math.atan(2 * x / (a * a * a)))
        print(r)


def calc2():
    if x >= V_div2:
        r = math.degrees(math.atan((a * b * b) / (2 * (V - x))))
        print(r)
    else:
        r = math.degrees(math.atan((a * b * b) / (2 * x)))
        print(r)


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

if a <= b:
    calc1()
    exit()
else:
    calc2()
    exit()

Submission status: Wrong Answer

Solution code:
import math
def ii():
    return int(input())
def mi():
    return map(int, input().split())
def li():
    return list(mi())

a, b, c = mi()
ratio = c / (a*a*b)
print(math.degrees(math.atan(ratio)))

Submission status: Wrong Answer

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

s = a*b - x/a
import math

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

Submission status: Wrong Answer

Solution code:
#coding: utf-8
from bisect import bisect_left
from decimal import Decimal

# n = int(input())
a,b,x = map(int,input().split())
vol = Decimal(a*a*b)
h = Decimal(x / (a**2))
p = Decimal(b/a)
ans = Decimal((vol-x)/vol*90*p)

print(ans)

Submission status: Wrong Answer

Solution code:
import math
a, b, x = map(int, input().split())
m = a*a*b
aa = a-x / (a*a)
bb = x / (a*b)
if a == 1:
    print(90-math.degrees(math.atan(((x/a/b))*2/b)))
elif aa > bb:
    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:
import math
a,b,x = map(int,input().split())
s = x/a/b*2
d = (a**2+s**2)**0.5
cos = s/d

print(math.degrees(math.acos(cos)))

Submission status: Wrong Answer

Solution code:
import math

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

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

Submission status: Wrong Answer

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

Submission status: Wrong Answer

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

Submission status: Wrong Answer

Solution code:
import math

def solv(a, b, x):
    if x == a ** 2 * b:
        return 0
    elif x <= a**2 * b / 2:
        tanTheta = (2 * x) / (a * b ** 2)
    else:
        tanTheta = (a ** 3) / 2 * (a ** 2 * b - x)
    return 90 - math.degrees(math.atan(tanTheta))

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

Submission status: Wrong Answer

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

Submission status: Wrong Answer

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

def koboreru_test(a, b, x, rad):
  if rad == 90:
    return (1)
  out = 0
  now_water = x
  max_water = a*a*b - pow(a,3) * math.tan(math.radians(rad)) / 2
  #print(max_water)
  if now_water > max_water:
    out = 1
  return (out)

rad = 0
ch_rate = 1
for i in range(1000000):
  d = koboreru_test(a, b, x, rad)
  if d == 0:
    rad += ch_rate
  else:
    rad -= ch_rate
    ch_rate = ch_rate * 0.5
print(rad)

Submission status: Wrong Answer

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

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

Submission status: Wrong Answer

Solution code:
import math

a, b, x = map(int, input().split())
if (x == a*a*b):
    ans = 90.0000000000
    print(ans)
else:
    x2 = x/a
    c = x2*2/a - b
    ans=math.atan(a/(b-c))
    ans = 90 - ans / math.pi * 180
    if c <= 0:
        c = x2*2 / b
        ans=math.atan(c/b)
        ans = 90 - ans / math.pi * 180
    print(ans)

Submission status: Wrong Answer

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

    c = (2*re_sq)/a
    tmp_theta = math.degrees(math.atan(c/a))
    theta = 90 - tmp_theta
print(theta)

Submission status: Wrong Answer

Solution code:
# D - Water Bottle
import math
a,b,x = map(int, input().split())

tmp = x/(a**2)
# tmp2 = x/(b**2)
tmp2 = (2*x/b)**(1/2)

if tmp2 < a:
    print(90-math.degrees(math.atan2(tmp2,a)))
else:
    #print(tmp)
    tmp3 = (2*b-((2*x)/(a*a)))
    #print(tmp3)
    print(90-math.degrees(math.atan2(a,tmp2)))

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

Submission status: Wrong Answer

Solution code:
import sys
import math

stdin = sys.stdin

ni = lambda: int(ns())
na = lambda: list(map(int, ns().split()))
ns = lambda: stdin.readline()

a, b, x = na()

ans = 0

V45 = (a*a*b)/2.0
if x >= V45:
    ans = math.degrees(math.atan( 2.0*((a*b)  - (x/a))))
else:
    ans = math.degrees(math.acos((2*x)/math.sqrt( (4*x*x) + (a*a*b*b*b*b))))
print(ans)

Submission status: Wrong Answer

Solution code:
# -*- coding: utf-8 -*-
import sys
import math
input = sys.stdin.readline


def main():
    a, b, x = map(int, input().split())
    b_d = b - (x / a**2)
    c = (a**2 + b_d**2)**0.5
    sin = b_d / c
    a_sin = math.asin(sin)

    print(math.degrees(a_sin))


if __name__ == '__main__':
    main()

Submission status: Wrong Answer

Solution code:
import math

a, b, x = map(float, input().split())
tan = math.degrees(math.tan(((2*x)-(2*a*a*b))/-(a*a*a)))
print(tan)

Submission status: Wrong Answer

Solution code:
import math

a,b,x = list(map(int,input().split()))
k = a*a*b - x
l = 3*k / (a**2)
cos = ((a*a)/(a*a)+(l*l))**0.5
print(90*(1-cos))

Submission status: Wrong Answer

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

import math

h = x/a**2

if (a**2)*b > x/2:
    s = 2*x/a**2 - b
    v = math.sqrt(a**2 + (b-s)**2)
    print(math.degrees(math.acos(a/v)))
    
else:
    s = 2*x/b**2
    print(math.degrees(math.acos(s/b)))

Submission status: Wrong Answer

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


if __name__ == '__main__':
    main()

Submission status: Wrong Answer

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

tan1 = (2/a)*(b - (x/(a**2)))
tan2 = (1/2)*(a*(b**2)/x)

actan = math.atan(tan1)
moto = (x/a**2)
gen = (a*math.tan(actan))
judge = (moto-gen) >= 0

if judge:
    tan = tan1
else:
    tan = tan2

actan = math.atan(tan)
degree = math.degrees(actan)
print(degree)

Submission status: Wrong Answer

Solution code:
import math 
a, b, x=map(int, input().split())
if x<a*a*b/3:
    angle=180*math.atan(a*b*b/2/x)/math.pi
    print('{:.10f}'.format(angle))
if x>=a*a*b/2:
    angle=180*math.atan((b-(x/a**2))/a*2)/math.pi
    print('{:.10f}'.format(angle))

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

Submission status: Wrong Answer

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

if a**(3)/2>x:
    print(ans2)
    quit()
print(ans1)

Submission status: Wrong Answer

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

import math

h = x/a**2

if (a**2)*b > x/2:
    s = 2*x/a**2 - b
    v = math.sqrt(a**2 + (b-s)**2)
    print(math.degrees(math.acos(a/v)))
    
else:
    s = 2*x/b**2
    print(math.degrees(math.acos(s/b)))

Submission status: Wrong Answer

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

Submission status: Wrong Answer

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

Submission status: Wrong Answer

Solution code:
import math

a, b, x = map(int, input().split())
if (x == a*a*b):
    print("90.000000000000")
else:
    x2 = x/a
    c = x2*2/a - b
    ans=math.atan(a/(b-c))
    ans = 90 - ans / math.pi * 180
    if c <= 0:
        c = x2*2 / b
        ans=math.atan(c/b)
        ans = 90 - ans / math.pi * 180
    print(ans)

Submission status: Wrong Answer

Solution code:
import numpy as np
import math
a,b,x=np.array(list(map(int, input().split())))
if x>=a*b/2:
    A=(2*b-2*x/a**2)/a
    if A<=0.01:
        print(math.degrees(A-A**3/3+A**5/5))
    else:
        print(np.rad2deg(np.arctan((2*b-2*x/a**2)/a)))
else:
    B=b/(2*x/a/b)
    if B<=0.01:
        print(360.0/2.0/np.pi*(B-B**3/3+B**5/5-B**7/7))
    else:    
        print(math.degrees(math.atan2(b,2*x/(a*b))))

Submission status: Wrong Answer

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

# 容器に入っている水が半分以下の場合に困る

if a*a*b > 2 * c:
    exit()
    h = (2*c)/(a*a)
    print(math.degrees(math.acos(h/a)))
else:
    h = 2*(a*a*b-c)/(a**2)
    print(math.degrees(math.atan(h/a)))

Submission status: Wrong Answer

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

Submission status: Wrong Answer

Solution code:
import math

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

full = a**2 * b

if x > full / 2:
    r = full - x
    print(math.degrees(math.atan(r/(a**3.00)*2.00)))
else:
    r = x
    print(90.00 - math.degrees(math.atan(r/(b**3.00)*2.00)))

Submission status: Wrong Answer

Solution code:
a, b, x = map(int, input().split())
v = a * a * b
if v > x:
  print(90 * (x / v))
else:
  print(4)

Submission status: Wrong Answer

Solution code:
import math

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

if a == b:
  atan1 = 45
  
elif a > b:
  y = ( 2 * x / b ) /a
 
  if y <= a:
    ans = y/b
    atan1 = math.degrees(math.atan(ans))
    atan1 = 90 - atan1
    
  else :
    y = (2 * x / (a * a)) - b
    ans = a/(b-y)
    atan1 = math.degrees(math.atan(ans))
    atan1 = 90 - atan1
  
elif b > a:
  y = (2 * x / (a * a)) - b
  
  if y < 0:
    y = ( 2 * x / b ) /a
    ans = y/b
    atan1 = math.degrees(math.atan(ans))
    atan1 = 90 - atan1
    atan1 = 0
    
  else:
    ans = a/(b-y)
    atan1 = math.degrees(math.atan(ans))
    atan1 = 90 - atan1
  
  
print(atan1)

Submission status: Wrong Answer

Solution code:
import math

a, b, x = map(int, input().split())
EPS = 10**(-8)

def bis(p, ok, ng):
    mid = (ok + ng) / 2
    return (
        ok if abs(ok - ng) <= EPS else
        bis(p, mid, ng) if p(mid) else
        bis(p, ok, mid)
    )

A = a**2
p = bis(lambda theta: a**2 * b * math.cos(theta / 180 * math.pi)**2 >= x, 0, 90)
q = bis(lambda theta: A * b - A * math.cos(theta / 180 * math.pi) * math.sin(theta / 180 * math.pi) / 2 >= x, 0, 90)
ans = min(p, q)
print(ans)

Submission status: Wrong Answer

Solution code:
import math
a, b,x = map(int, input().split())
y=x/(b*1.0)/(a*1.0)
z=math.sqrt(y*y+b*b)

d=(b) / (z *1.0)

rad = math.acos(d)

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

Submission status: Wrong Answer

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


if __name__ == '__main__':
    main()

Submission status: Wrong Answer

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

s = a*b - x/a
import math

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

Submission status: Wrong Answer

Solution code:
import math

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

if a == b:
  atan1 = 45
  
elif a > b:
  y = ( 2 * x / b ) /a
 
  if y <= a:
    ans = y/b
    atan1 = math.degrees(math.atan(ans))
    atan1 = 90 - atan1
    atan1 = 0
    
  else :
    y = (2 * x / (a * a)) - b
    ans = a/(b-y)
    atan1 = math.degrees(math.atan(ans))
    atan1 = 90 - atan1
  
elif b > a:
  y = (2 * x / (a * a)) - b
  
  if y < 0:
    y = ( 2 * x / b ) /a
    ans = y/b
    atan1 = math.degrees(math.atan(ans))
    atan1 = 90 - atan1
    
  else:
    ans = a/(b-y)
    atan1 = math.degrees(math.atan(ans))
    atan1 = 90 - atan1
  
  
print(atan1)

Submission status: Wrong Answer

Solution code:
import math

a, b, x = map(int, input().split())
if (x == a*a*b):
    print("90.0")
else:
    x2 = x/a
    c = x2*2/a - b
    ans=math.atan(a/(b-c))
    ans = 90 - ans / math.pi * 180
    if c <= 0:
        c = x2*2 / b
        ans=math.atan(c/b)
        ans = 90 - ans / math.pi * 180


    print(ans)

Submission status: Wrong Answer

Solution code:
import math


a, b, x = map(int, input().split())
r = 180 / math.pi
h = x / a ** 2
c = h * 2 - b
h2 = x / (a * b)
d = 2 * x / b
if h >= b / 2:
    th = math.atan((h - c) / (a / 2)) * r
else:
    th = ((math.pi / 2) - math.atan((d - h2) / (b / 2))) * r
print(th)

Submission status: Wrong Answer

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

Submission status: Wrong Answer

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

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

Submission status: Wrong Answer

Solution code:
def main():
    a, b, x = map(int, input().split())
    deg = 0
    h = x / a ** 2
    if h <= b / 2:
        h2 = (x / b ** 2) * 2
        deg = 90 - 90 * h2 / (a + b)
    else:
        h3 = (a ** 2 * b - x) / a * 2
        deg = 90 - 90 * h3 / (a + b)
    print(deg)


if __name__ == '__main__':
    main()

Submission status: Wrong Answer

Solution code:
import math

a, b, x = map(int, input().split())
#d = x / a**2	# 水の深さ
s = x / a	# 側面積

if s == a * b:	# 満杯
  print(0)
  exit()

if a <= b:
  l = s * 2 / b	# 傾けた時（側面＝三角形）の底辺長
  print(math.degrees(math.atan(b/l)))
else:
  l = s * 2 / a - b	# 傾けた時（側面＝台形）の上辺長
  print(math.degrees(math.atan((b-l)/a)))

Submission status: Wrong Answer

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

Submission status: Wrong Answer

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

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

Submission status: Wrong Answer

Solution code:
import math

class _const:
    def __init__(self):
        self.PI=math.acos(-1)
        self.convToDEG=180/self.PI
const=_const()


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

Volume=a*a*b

if 2*x>=Volume:
    print(const.convToDEG*math.atan(2*(a*a*b-x)/a**3))

else:
    h=2*x/(a*b)
    if(h/b<=1):
        print(const.convToDEG*math.acos(h/b))
    else:
        print("0")

Submission status: Wrong Answer

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

#ans = max(90 - degrees(atan(0.5 * a ** 3/(a ** 2 * b - x))), 90 - degrees(atan(2 * x / (a * b ** 2))))
if a ** 2 * b == x:
    ans = 90
else:
    if 0.5 * a ** 2 * b < x:
        ans = 90 - degrees(atan(0.5 * a ** 3/(a ** 2 * b - x)))
    else:
        ans = 90 - degrees(atan(2 * x / (a * b ** 2)))

print(ans)

Submission status: Wrong Answer

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

import math

if x <= rect / 2:
    AreaTriangle = x / a
    slopeB = AreaTriangle * 2 / b
    slopeC = pow(b**2+slopeB**2, 0.5)
    height = AreaTriangle * 2 / slopeC
    #print(AreaTriangle, slopeB, slopeC, height, height / a)
    angle = 90 - math.degrees(math.asin(height / a))
    print(angle)
else:
    AreaTriangle = (rect - x) / a
    slopeB = AreaTriangle * 2 / a
    slopeC = pow(b**2+slopeB**2, 0.5)
    height = AreaTriangle * 2 / slopeC
    #print(AreaTriangle, slopeB, slopeC, height, height/a)
    angle = math.degrees(math.asin(height / a))
    print(angle)

Submission status: Wrong Answer

Solution code:
A, B, X = [int(n) for n in input().split()]

def main():
    c = (A ** 2) * B
    ans = 90 * X / c
    print(90 - ans)

if __name__ == '__main__':
    main()

Submission status: Wrong Answer

Solution code:
import math

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

ans = math.radians(90)-math.atan((2*x)/(a*b*b))

print(math.degrees(ans))

Submission status: Wrong Answer

Solution code:
import math
a, b, x = map(int, input().split())
 
h = x / (a * a) #height 
if h > b / 2:
  shahen = 4 * (b - x/(a * a)) * (b - x/(a * a)) + a * a
  sin = a / (math.sqrt(shahen))
  print(90 - math.degrees(math.asin(sin)))
elif h == b / 2:
  print("45.0000000000")
else:
  shahen = 4 * x * x + a * a * b * b * b * b
  sin = 2 * x / (math.sqrt(shahen))
  print(sin)
  print(90 - math.degrees(math.asin(sin)))

Submission status: Wrong Answer

Solution code:
import math

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

tan_n_2 = (a**2) * b / x
tan_n = math.sqrt(tan_n_2)
n = math.degrees(math.atan(tan_n))

print(n)

Submission status: Wrong Answer

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

import math

if x <= rect / 2:
    AreaTriangle = x / a
    slopeB = AreaTriangle * 2 / b
    slopeC = pow(b**2+slopeB**2, 0.5)
    height = AreaTriangle * 2 / slopeC
    print(AreaTriangle, slopeB, slopeC, height, height / a)
    angle = 90 - math.degrees(math.asin(height / a))
    print(angle)
else:
    AreaTriangle = (rect - x) / a
    slopeB = AreaTriangle * 2 / a
    slopeC = pow(b**2+slopeB**2, 0.5)
    height = AreaTriangle * 2 / slopeC
    print(AreaTriangle, slopeB, slopeC, height, height/a)
    angle = math.degrees(math.asin(height / a))
    print(angle)

Submission status: Wrong Answer

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

Submission status: Wrong Answer

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

Submission status: Wrong Answer

Solution code:
import numpy as np


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

if x < a * a * b / 2:
    print(np.rad2deg(np.arctan(b * b / x / 2)))
else:
    print(np.rad2deg(np.arctan(2 * (b - x / (a ** 2)) / a)))

Submission status: Wrong Answer

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

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

import math

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

Submission status: Wrong Answer

Solution code:
import math
a, b, x = map(int, input().split())
 
h = x / (a * a) #height 
if h > b / 2:
  shahen = 4 * (b - x/(a * a)) * (b - x/(a * a)) + a * a
  sin = a / (math.sqrt(shahen))
  print(90 - math.degrees(math.asin(sin)))
elif h == b / 2:
  print(45.0000000000)
else:
  shahen = 4 * x * x + a * a * b * b * b * b
  sin = 2 * x / (math.sqrt(shahen))
  print(sin)
  print(90 - math.degrees(math.asin(sin)))

Submission status: Wrong Answer

Solution code:
import math
abx = input().split(' ')

a = int(abx[0])
b = int(abx[1])
x = int(abx[2])

all_S =a*a*b
empty_area = all_S -x
print(x,empty_area)
if empty_area > x:
    small_s = (all_S/2) - (empty_area - (all_S/2))
    y = ((small_s*2)/(a*b) -a) *(-1)
    sita = math.degrees(math.atan((a - y)/b))
    print(90 - sita)
else:
    y = ((empty_area*2/(a*a))-b) * (-1)
    #print(y)
    sita = math.degrees(math.atan((b - y)/a))
    print(sita)

Submission status: Wrong Answer

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

Submission status: Wrong Answer

Solution code:
import math
a, b, x = map(int, input().split())
m = a*a*b
aa = a-x / (a*a)
bb = x / (a*b)
if aa >= bb:
    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:
import math

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

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

Submission status: Wrong Answer

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

Submission status: Wrong Answer

Solution code:
#!/usr/bin/env python3
import numpy as np

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

Y = a * a * b - x
h = (2 * Y) / (a * a)

# ans = np.arctan2(h, a) * 180 / np.pi
ans = np.arctan2(h, a)
ans = np.rad2deg(ans)
# ans = math.degrees(ans)

if ans > 45.0:
    h = (2 * x) / (a * b)
    # ans = np.arctan2(b, h) * 180 / np.pi
    ans = np.arctan2(b, h)
    ans = np.rad2deg(ans)

# if x == a * a * b:
#     ans = 0

print(ans)

Submission status: Wrong Answer

Solution code:
import math

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

print(atan1)

Submission status: Wrong Answer

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

Submission status: Wrong Answer

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

Submission status: Wrong Answer

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