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())
p=math.atan(2*x/a*b)
q=90-p
print(q)

Submission status: Wrong Answer

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

Submission status: Wrong Answer

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

Submission status: Wrong Answer

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

ans_rad = np.arctan(2 * x / (a * b**2))
ans = 90 - ans_rad * (180 / pi)
print("{}".format(ans))

Submission status: Wrong Answer

Solution code:
import math
A,B,C = list(map(int,input().split()))
V = A**2 * B
r = math.atan(2 * (V - C) / (A ** 3))
ans = math.degrees(r)
print('{:.11f}'.format(ans))

Submission status: Wrong Answer

Solution code:
import math
A,B,C = list(map(int,input().split()))
V = A**2 * B
r = math.atan(2 * (V - C) / (A ** 3))
ans = math.degrees(r)
print(ans)

Submission status: Wrong Answer

Solution code:
# -*- coding: utf-8 -*-
import math
def main():
    a, b, x = map(int, input().split())
    theta = None
    if 2*x <= a*a*b:
        theta = math.atan((a*b*b)/(2*x))
    else:
        theta = math.atan(2*(a*a*b-x)/(a**3))
        print("ok")
    print(math.degrees(theta))

if __name__ == "__main__":
    main()

Submission status: Wrong Answer

Solution code:
# -*- coding: utf-8 -*-
import math
def main():
    a, b, x = map(int, input().split())
    theta = math.atan((a*b*b)/(2*x))
    print(math.degrees(theta))

if __name__ == "__main__":
    main()

Submission status: Wrong Answer

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

Submission status: Wrong Answer

Solution code:
a, b, x = map(int, input().split())
from decimal import Decimal
import math
a = Decimal(str(a))
b = Decimal(str(b))
x = Decimal(str(x))
two = Decimal('2')
from decimal import Decimal
h = x / a ** 2
h = Decimal(h)
#print(h)
h = x / a ** Decimal(str(2))
print(math.degrees(two * Decimal(str(math.atan(b - h))) / a))

Submission status: Wrong Answer

Solution code:
import sys
input=sys.stdin.readline
#K = int(input())
#S = input()[:-1]
a,b,x = map(int,input().split())

#S,T = map(str,input().split())
#A = list(map(int,input().split()))
#A = [int(input()) for _ in range(N)]
#S = [input() for _ in range(N)]
#A = [list(map(int,input().split())) for _ in range(N)]
import math
v = a*a*b
if x <= v/2:
    d = 2 * x / (a*b*b)
    th = math.degrees(math.atan(d))
    print(90-th)
elif x < v:
    
    d = 2*(v-x)/(a*a*a)
    th = math.degrees(math.atan(d))
    print(th)

Submission status: Wrong Answer

Solution code:
import sys
input=sys.stdin.readline
#K = int(input())
#S = input()[:-1]
a,b,x = map(int,input().split())
#S,T = map(str,input().split())
#A = list(map(int,input().split()))
#A = [int(input()) for _ in range(N)]
#S = [input() for _ in range(N)]
#A = [list(map(int,input().split())) for _ in range(N)]
import math
v = a*a*b
if x <= v/2:
    d = 2 * x / (a*b*b)
    th = math.degrees(math.atan(d))
    print(th)
elif x < v:
    d = a*a*a/(2*(a*a*b-x))
    th = math.degrees(math.atan(d))
    print(d)
else:
    print(0)

Submission status: Wrong Answer

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

Submission status: Wrong Answer

Solution code:
import math

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

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

Submission status: Wrong Answer

Solution code:
import math

y = input().split()
a = int(y[0])
b = int(y[1])
x = int(y[2])

v = b*a*a
c = math.sqrt(a*a+b*b)

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

Submission status: Wrong Answer

Solution code:
import math

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

Submission status: Wrong Answer

Solution code:
import math

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

Submission status: Wrong Answer

Solution code:
import math

a,b,x = map(int,input().split())
if (a**2)*b == x:
    print(0)
else:
    if 2*(a**2)*b <= 2*(a**2)*x:
        print(math.degrees(math.atan2(2*((a**2)*b-x), a**3)))
    else:
        print(math.degrees(math.atan2(a*(b**2), 2*x)))

Submission status: Wrong Answer

Solution code:
import math

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

Submission status: Wrong Answer

Solution code:
import math

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

Submission status: Wrong Answer

Solution code:
import math

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

Submission status: Wrong Answer

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

Submission status: Wrong Answer

Solution code:
from decimal import *
import math
a,b,x=map(int,input().split())
height=Decimal(x)/Decimal(a*a)

y1=Decimal(2*a*height)/Decimal(b)
if y1>b:#a*height=(b+y)*a/2<=>y=2height-b
    y1=b-(2*height-b)
    print(math.degrees(math.atan(y1/a)))
else:#a*height=b*y/2なるy<=>y=2*a*height/b
    print(math.degrees(math.atan(b/y1)))

Submission status: Wrong Answer

Solution code:
import math
a,b,x=map(int,input().split())
height=x/(a*a)
#a*height=b*y/2なるy<=>y=2*a*height/b
y1=(2*a*height)/b
if y1>b:#a*height=(b+y)*a/2<=>y=2height-b
    y1=b-(2*height-b)
    print(math.degrees(math.atan(y1/a)))
else:
    print(math.degrees(math.atan(b/y1)))

Submission status: Wrong Answer

Solution code:
import math

def volume(a,b,t):
    if  b>a*t :#台形パターン
        v =  a*a*b-(0.5*(a**3))*t
    else:#三角形パターン
        v =0.5*b*b*a/t
    return v
  
a, b, x = map(int, input().split())
LR = [0,9*(10**9)]
if x == 0:
    print(0)
else:
    while LR[1]-LR[0]>1:
        mid = 0.5*(LR[0]+LR[1])
        v= volume(a,b,math.tan(math.radians(mid/10**8)))
        if v >x:
            LR[0]=mid
        else:
            LR[1]=mid
    #     print("v==={}\nx==={}\ntan==={}\n{}\n".format(v,x,math.tan(math.radians(mid/10**7)),LR))
    #     time.sleep(1)
    print(LR[0]/10**8)
    print(LR[1]/10**8)

Submission status: Wrong Answer

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

Submission status: Wrong Answer

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

Submission status: Wrong Answer

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

Submission status: Wrong Answer

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

Submission status: Wrong Answer

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

Submission status: Wrong Answer

Solution code:
import math
a, b, x = map(int, input().split())
s = 90
d = 0.00001
flag = False
for i in range(int(s/d)):
    if not flag:
        m = a/math.tan(math.radians(s))
        n = x/(a**2) - m/2
        if n < 0:
            flag = True
        elif m + n > b:
            break
    else:
        m = (2*x/(a*math.tan(math.radians(s))))**0.5
        if m > b:
            break
    s -= d
print(90-s)

Submission status: Wrong Answer

Solution code:
import math
a, b, x = map(int, input().split())
s = 90
d = 0.0005
flag = False
for i in range(int(s/d)):
    if not flag:
        m = a/math.tan(math.radians(s))
        n = x/(a**2) - m/2
        if n < 0:
            flag = True
        elif m + n > b:
            break
    else:
        m = (2*x/(a*math.tan(math.radians(s))))**0.5
        if m > b:
            break
    s -= d
print(90-s)

Submission status: Wrong Answer

Solution code:
from math import degrees, atan2

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

S = x / a
if S >= a * b / 2:
    h = 2 * (a * b - S) / a
    theta = atan2(h, a)
else:
    w = S / b
    theta = atan2(b, w)
print(degrees(theta))

Submission status: Wrong Answer

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

Submission status: Wrong Answer

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

Submission status: Wrong Answer

Solution code:
import sys
#import bisect
#from collections import deque
import math

def input():
    return sys.stdin.readline().rstrip('\n')


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

if a*a*b/2 > x:
    adash = x / a / b * 2
    # tan(theta) = adash / b
    theta = math.atan(adash/b)
    # convert radian to degree  (2 * pi radian = 360 degree)
    theta_degree = theta * 180 / math.pi
    print(90-theta_degree)
else:
    adash = ((a*a*b)-x) / a / a * 2
    print(adash)
    # tan(theta) = adash / a
    theta = math.atan(adash/a)
    # convert radian to degree  (2 * pi radian = 360 degree)
    theta_degree = theta * 180 / math.pi
    print(theta_degree)

Submission status: Wrong Answer

Solution code:

import math


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

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

if __name__ == "__main__":
    submit()

Submission status: Wrong Answer

Solution code:
from math import atan2, degrees

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

theta = 0
if x < a * b / 2:
    theta = atan2(b, 2 * x ** 2 / a / b ** 2)
else:
    theta = atan2(2 * b - 2 * x / a ** 2, a)

print(degrees(theta))

Submission status: Wrong Answer

Solution code:
#!usr/bin/env python3
from collections import defaultdict,deque
from heapq import heappush, heappop
import sys
import math
import bisect
import random
def LI(): return [int(x) for x in sys.stdin.readline().split()]
def I(): return int(sys.stdin.readline())
def LS():return [list(x) for x in sys.stdin.readline().split()]
def S():
    res = list(sys.stdin.readline())
    if res[-1] == "\n":
        return res[:-1]
    return res
def IR(n):
    return [I() for i in range(n)]
def LIR(n):
    return [LI() for i in range(n)]
def SR(n):
    return [S() for i in range(n)]
def LSR(n):
    return [LS() for i in range(n)]

sys.setrecursionlimit(1000000)
mod = 1000000007

def solve():
    a,b,x = LI()
    if b-x/a**2 < a:
        print(math.atan(2*(b-x/a**2)/a)*180/math.pi)
    else:
        print(math.atan(a*b**2/2/x)*180/math.pi)
    return

#Solve
if __name__ == "__main__":
    solve()

Submission status: Wrong Answer

Solution code:
# 二分探索
import math
def containable_vol(a, b, theta):
    if a*math.sin(theta) < b*math.sin(math.pi / 2 - theta):
        return (a**2 * b) / 2 + (a**2 / math.sin(math.pi / 2 - theta))*(b*math.sin(math.pi / 2 - theta) - a*math.sin(theta))
    else:
        return b**2*math.tan(math.pi / 2 - theta)*a / 2

a, b, x = map(int, input().split())
left, right = 0, math.pi / 2
max_theta = 0
while left < right:
    mid = (left + right) / 2
    if containable_vol(a, b, mid) == x:
        max_theta = mid
        break
    if x < containable_vol(a, b, mid):
        left = mid + 0.00000000001
        max_theta = mid
    elif x > containable_vol(a, b, mid):
        right = mid - 0.00000000001
print(math.degrees(max_theta))

Submission status: Wrong Answer

Solution code:
# 二分探索
import math
def containable_vol(a, b, theta):
    if a*math.sin(theta) < b*math.sin(math.pi / 2 - theta):
        return (a**2 * b) / 2 + (a**2 / math.sin(math.pi / 2 - theta))*(b*math.sin(math.pi / 2 - theta) - a*math.sin(theta))
    else:
        return b**2*math.tan(math.pi / 2 - theta)*a / 2

a, b, x = map(int, input().split())
left, right = 0, math.pi / 2
max_theta = 0
while left < right:
    mid = (left + right) / 2
    if containable_vol(a, b, mid) == x:
        max_theta = mid
        break
    if x < containable_vol(a, b, mid):
        left = mid + 0.000000001
        max_theta = mid
    elif x > containable_vol(a, b, mid):
        right = mid - 0.000000001
print(math.degrees(max_theta))

Submission status: Wrong Answer

Solution code:
# 二分探索
import math
def containable_vol(a, b, theta):
    if a*math.sin(theta) < b*math.sin(math.pi / 2 - theta):
        return (a**2 * b) / 2 + (a**2 / math.sin(math.pi / 2 - theta))*(b*math.sin(math.pi / 2 - theta) - a*math.sin(theta))
    else:
        return b**2*math.tan(math.pi / 2 - theta)*a / 2

a, b, x = map(int, input().split())
left, right = 0, math.pi / 2
max_theta = 0
while left < right:
    mid = (left + right) / 2
    if containable_vol(a, b, mid) == x:
        max_theta = mid
        break
    if x < containable_vol(a, b, mid):
        left = mid + 0.0001
        max_theta = mid
    elif x > containable_vol(a, b, mid):
        right = mid
print(math.degrees(max_theta))

Submission status: Wrong Answer

Solution code:
import math

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

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

print(math.atan(arg) / math.pi * 180)

Submission status: Wrong Answer

Solution code:
import math

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


arg = (2 * b / a) - (2 * x / (a ** 3))
if arg <= math.atan(b / a):
	#θ <= atan(b / a)
	print(math.atan(arg) / math.pi * 180)
else:
	#θ > atan(b / a)
	arg = (a * (b ** 2)) / (2 * x)
	print(math.atan(arg) / math.pi * 180)

Submission status: Wrong Answer

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

Submission status: Wrong Answer

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

Submission status: Wrong Answer

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

Submission status: Wrong Answer

Solution code:
def fl(x):
    digits = 8
    form = '%.'+str(digits-1)+'e'
    return float((form % x))
a,b,x=map(int,input().split())
import math
if x==b*a**2:
    print(0)
else:
    if x >= a * b / 2:
        print(90 - math.degrees(math.atan(fl(a / 2 / (b - fl(x / a ** 2))))))
    else:
        tate = fl(2 * x / a / b)
        print(90 - math.degrees(math.atan(fl(tate / b))))

Submission status: Wrong Answer

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

Submission status: Wrong Answer

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

Submission status: Wrong Answer

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

Submission status: Wrong Answer

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

Submission status: Wrong Answer

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

Submission status: Wrong Answer

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

Submission status: Wrong Answer

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

Submission status: Wrong Answer

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

Submission status: Wrong Answer

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

if a * a * b == x:
    print(90)
# 台形の場合
elif a * a * b < 2 * x:
    y = 2 * x / (a*a) - b
    print(90 - math.degrees(math.atan(a/(b-y))))

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

Submission status: Wrong Answer

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

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

Submission status: Wrong Answer

Solution code:
import sys

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

print(a)
print(b)
print(x)

if(x > a*a*b):
    sys.exit()

suito = a * a * b

wariai = 0

wariai = x / suito

kakudo = 0
kakudo =90 * wariai
print(90-kakudo)

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

Submission status: Wrong Answer

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

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

Submission status: Wrong Answer

Solution code:
#!/usr/bin/env python3
#input
import math
# math.degrees(theta) = theta radian to kodo
# math.atan(math.tan(theta)) = theta
a,b,x = map(int,input().split())
if x <= a*a*b/2:
    tan = (a*b*b)/2*x
else:
    tan = 2*(a*a*b-x)/(a**3)
print(math.degrees(math.atan(tan)))

Submission status: Wrong Answer

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

from math import atan, pi
if x>a*a*b/2:#半分よりも多い場合
    theta=atan(2*(a*a*b)/a*a*a)
else:
    theta=atan((a*b*b)/(2*x))
theta = theta * 180 / pi
print(theta)

Submission status: Wrong Answer

Solution code:
import math

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


if __name__ == "__main__":
    main()

Submission status: Wrong Answer

Solution code:
import math

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

vol = a**2 * b
ans = 0
if vol/2 < x:
    print("水多し、台形になる")
    h0 = x/(a**2)
    c = 2*h0 - b
    ans = math.degrees(math.atan((b-c)/a))
else:
    print("水少ない、三角形になる")
    d = (2*x)/(b*a)
    ans = math.degrees(math.atan(b/d))
print(ans)

Submission status: Wrong Answer

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

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

Submission status: Wrong Answer

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

if x >= a*b/2:
  print(round(degrees(atan((b-x/(a**2))*2/a)),7))
else:
  print(round(degrees(atan(a*(b**2)/(2*x))),7))

Submission status: Wrong Answer

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

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

Submission status: Wrong Answer

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

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

Submission status: Wrong Answer

Solution code:
import math

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

bottle = a * b
water = x / a

if water <= bottle / 2:
  a2 = 2 * water / b
  ans = math.degrees(math.atan(b / a2))
  
else:
  b2 = 2 * water / a - b
  water2 = water - (b2 * a)
  b3 = water2 / a
  ans = math.degrees(math.atan(b3 / a))
  
print(ans)

Submission status: Wrong Answer

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

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

print(atan0)

Submission status: Wrong Answer

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

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

print(round(atan0, 10))

Submission status: Wrong Answer

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

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

print(round(atan0, 5))

Submission status: Wrong Answer

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

s = x / a

if s * 2 >= a * b:
  k = (2 * a * b - 2 * s) / a
  r = math.atan2(a, k)
  print(math.degrees(r))

else:
  k = (2 * s) / b
  r = math.atan2(b, k)
  print(math.degrees(r))

Submission status: Wrong Answer

Solution code:
# 実装と発想がむずいにぶたん
# というか最初は誰でもO(1)を考えるよなこれ にぶたんはむしろ少数派では
# でもこれを見た瞬間やるだけと言ってるヒトはちょっとよくわからん

# theta°（0~90）傾けたとき溢れるかどうかってどうやって判断するの？？？？
# 横から見たときの面積から体積がわかるのでそれかな...（面積S=x/aなので）
# 紙に書いたらわかってきた
# 筒を横から見たときの面積は a*b
# 斜めに限界ギリギリまで傾けたときの三角形になる部分はxがa*bより上か下かで変わる
# 三角形のが求めやすいのでそうして、θ°傾けたときにその面積を出してS(=x/a)と合わせてx/aを越えるかどうかでわかりそうだね（横からみたときの面積はこぼれない限り一定なので）

import math

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

l, r = 0.0, 90.0
# 筒を横からみたときの面積の半分を、横からみたときの水の面積が超えていれば、半分以上入っていることになる、のでは。。。。。
if a * b / 2.0 > (x / a):
    # 半分未満の場合
    # な  ん  で これが間違ってるんだ？？？？？？？？？？？？？？？？？？？？？
    while l + 10 ** (-8) < r:
        theta = (l + r) / 2.0
        # 限界まで傾けたときの筒を横から見た時、水の入ってる部分はbを対辺とする直角三角形で、底辺をeとすると
        # tan(theta) = b / e -> e = b / tan(theta)
        # よって面積は (e * b)/2 -> (b/tan(theta)*b)/2
        s2 = (b * b / math.tan(math.radians(theta))) / 2.0
        if (x / a) + s2 < a * b:
            l = theta
        else:
            r = theta
else:
    # 半分以上の場合
    while l + 10 ** (-8) < r:
        theta = (l + r) / 2.0
        # 限界まで傾けたときの筒を横から見た時、水の入っていない部分が直角三角形になる
        # 底辺がaなので、対辺をeとすると、tan(theta) = e/a -> e = a * tan(theta)
        # なので三角形の面積は (a * tan(theta) * a)/ 2
        # 同じくラジアンに変換して渡す
        s2 = (a * math.tan(math.radians(theta)) * a) / 2.0
        if (x / a) + s2 < a * b:
            l = theta
        else:
            r = theta
print(l)

Submission status: Wrong Answer

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

Submission status: Wrong Answer

Solution code:
import sys,math

sys.setrecursionlimit(10 ** 6)
int1 = lambda x: int(x) - 1
p2D = lambda x: print(*x, sep="\n")
def IS(): return sys.stdin.readline()[:-1]
def II(): return int(sys.stdin.readline())
def MI(): return map(int, sys.stdin.readline().split())
def LI(): return list(map(int, sys.stdin.readline().split()))
def LI1(): return list(map(int1, sys.stdin.readline().split()))
def LII(rows_number): return [II() for _ in range(rows_number)]
def LLI(rows_number): return [LI() for _ in range(rows_number)]
def LLI1(rows_number): return [LI1() for _ in range(rows_number)]

def main():
	a,b,x =MI()
	V = a*a*b
	if(V*0.5 >= x):
		t=2*x/(a*b)
		print(t)
		ans = 90 -math.degrees(math.atan(t/b))
	else:
		t=(2*x-(a**2)*b)/(a**2)
		t = b-t
		ans = math.degrees(math.atan(t/a))
	print(ans)
main()

Submission status: Wrong Answer

Solution code:
import numpy as np
a, b ,x = map(float, input().split())
n = x/a
s = np.degrees([np.arctan(np.power(b, 2.0)/(2*n)), np.arctan(2*n*np.power(a, -2.0))])
print(s[0] if np.degrees(np.arctan(a/b))<s[0] else s[1])

Submission status: Wrong Answer

Solution code:
import numpy as np
a, b ,x = map(float, input().split())
n = x/a
s = np.degrees([np.arctan(np.power(b, 2.0)/(2*n)), np.arctan(2*n*np.power(a, -2.0))])
print(s[0] if np.arctan(a/b)<s[0] else s[1])

Submission status: Wrong Answer

Solution code:
import numpy as np
a, b ,x = map(float, input().split())
s = np.degrees([np.arctan(a*np.power(b, 2)/(2*x)), np.arctan(2*(np.power(a, 2)*b-x)/(np.power(a, 3)))])
print(s[0] if np.degrees(np.arctan(a/b))<=s[0] else s[1])

Submission status: Wrong Answer

Solution code:
import numpy as np
a, b ,x = map(float, input().split())
s = np.degrees([np.arctan(a*np.power(b, 2)/(2*x)), np.arctan(2*(np.power(a, 2)*b-x)/(np.power(a, 3)))])
print(s[0] if np.degrees(np.arctan(a/b))<45.0 else s[1])

Submission status: Wrong Answer

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

Submission status: Wrong Answer

Solution code:
import numpy as np
a, b, x = map(float, input().split())
print(np.degrees(np.arctan((2.0*(np.power(a, 2.0)*b-x))*np.power(a, -3.0))))

Submission status: Wrong Answer

Solution code:
import numpy as np
a, b, x = map(int, input().split())
print(np.degrees(np.arctan((2*(np.power(a, 2.0)*b-x))*np.power(a, -3.0))))

Submission status: Wrong Answer

Solution code:
import numpy as np
a, b, x = map(int, input().split())
print(np.degrees(np.arctan(\
2.0*(np.power(a, 2.0)*b-x)*np.power(a,-3.0)\
)))

Submission status: Wrong Answer

Solution code:
import numpy as np
a, b, x = map(int, input().split())
print(np.degrees(np.arctan(2*(np.power(a, 2)*b-x)*np.power(a, -3))))

Submission status: Wrong Answer

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

Submission status: Wrong Answer

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

Submission status: Wrong Answer

Solution code:
import math
import sys
a,b,x = map(int,input().split())
if a*a*b == x:
    print(90)
    sys.exit()
tan = a**3/(2*(a**2*b-x))
if tan<=(a/b):
    tan = 2*x/(b**2*a)
rad = math.atan(tan)
deg= 90- (rad * 180/math.pi)
print(deg)

Submission status: Wrong Answer

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

import math

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

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

print(90-math.degrees(theta))

Submission status: Wrong Answer

Solution code:
import math
a,b,x = map(int,input().split())
def f(t):
    t = math.radians(t)
    if a * math.tan(t) <= b:
        return a**2 * b - a**2 * math.tan(t) / 2
    else:
        return b**2 / math.tan(t) * a / 2
tmax = 90
tmin = 0
for i in range(10**5):
    tmid = tmin + (tmax-tmin) / 2
    if f(tmid) < x:
        tmax = tmid
    else:
        tmin = tmid
print(tmid)

Submission status: Wrong Answer

Solution code:
import math
a,b,x = map(int,input().split())
def f(t):
    t = math.radians(t)
    if a * math.tan(t) <= b:
        return a**2 * b - a**2 * math.tan(t) / 2
    else:
        return b**2 / math.tan(t) * a / 2
tmax = 90
tmin = 0
for i in range(10**6):
    tmid = tmin + (tmax-tmin) / 2
    if f(tmid) < x:
        tmax = tmid
    else:
        tmin = tmid
print(tmid)

Submission status: Wrong Answer

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

import math

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

Submission status: Wrong Answer

Solution code:
import math

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

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

Submission status: Wrong Answer

Solution code:
from math import *

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

if((a**2)*b/2 > x):
    print("a")
    print(degrees(atan(a*b**2/(2*x))))
else:
    print(degrees(atan( (2*(a**2 * b - x) / a**3))))

Submission status: Wrong Answer

Solution code:
from math import atan
from math import degrees

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