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: Accepted

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():
    pi = 3.141592653589793238
    a,b,x = LI()
    h = x/a**2
    s = x/a
    theta = 180*math.atan(2*(b-h)/a)/pi
    theta2 = 180*math.atan(2*h/a)/pi
    if theta < theta2:
        print(theta)
    else:
        print(180*math.atan((b**2)/2/s)/pi)
    return

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

Submission status: Accepted

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

Submission status: Accepted

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

Submission status: Accepted

Solution code:
import math

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

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

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

Submission status: Accepted

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

Submission status: Accepted

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

Submission status: Accepted

Solution code:
#!/usr/bin/env python3
import sys
import math
INF = float("inf")


def solve(a: int, b: int, x: int):
    base = a*a*b/2
    if x >= base:
        theta = math.atan(2*(x-a*a*b)/(a*a*a))
    else:
        theta = math.atan(a*b*b/(2*x))
    print(abs(math.degrees(theta)))

    return


def main():

    def iterate_tokens():
        for line in sys.stdin:
            for word in line.split():
                yield word
    tokens = iterate_tokens()
    a = int(next(tokens))  # type: int
    b = int(next(tokens))  # type: int
    x = int(next(tokens))  # type: int
    solve(a, b, x)


if __name__ == '__main__':
    main()

Submission status: Accepted

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


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

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

Submission status: Accepted

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

Submission status: Accepted

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

Submission status: Accepted

Solution code:
import sys,collections as cl,bisect as bs,math 
sys.setrecursionlimit(100000)
mod = 10**9+7
Max = sys.maxsize
def l(): #intのlist
    return list(map(int,input().split()))
def m(): #複数文字
    return map(int,input().split())
def onem(): #Nとかの取得
    return int(input())
def s(x): #圧縮
    a = []
    aa = x[0]
    su = 1
    for i in range(len(x)-1):
        if aa != x[i+1]:
            a.append([aa,su])
            aa = x[i+1]
            su = 1
        else:
            su += 1
    a.append([aa,su])
    return a
def jo(x): #listをスペースごとに分ける
    return " ".join(map(str,x))
def max2(x): #他のときもどうように作成可能
    return max(map(max,x))
def In(x,a): #aがリスト(sorted)
    k = bs.bisect_left(a,x)
    if k != len(a) and a[k] ==  x:
        return True
    else:
        return False

def prime_decomposition(n): #素因数分解
  i = 2
  table = []
  while i * i <= n:
    while n % i == 0:
      n /= i
      table.append(i)
    i += 1
  if n > 1:
    table.append(int(n))
  return table

def make_divisors(n): #約数列挙
    divisors = []
    for i in range(1, int(n**0.5)+1):
        if n % i == 0:
            divisors.append(i)
            if i != n // i:
                divisors.append(n//i)

    # divisors.sort()
    return divisors




a,b,x = m()

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

elif x >= a*a*b/2:
    kkk = 2 * x / (a**2) - b

    on = b - kkk

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

    k = math.degrees(math.atan(b/kkk))
    print(k)

Submission status: Accepted

Solution code:
import numpy as np

a,b,x = list(map(int,input().split()))
if x/(a**2) > b/2:
    print(np.arctan((b - x/(a**2)) / (a/2))*(180 /np.pi))
else:
    y = 2*x/(b*a)
    print(np.arctan(b / y)*(180 /np.pi))

Submission status: Accepted

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

Submission status: Accepted

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

Submission status: Accepted

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

Submission status: Accepted

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

from math import atan,degrees

# 面積にする
X=x/a

if X < a*b/2:
    d = 2*X/b
    print(degrees(atan(b/d)))
else:
    d = (X-a*b/2) /a*2
    print(degrees(atan( (b-d)/a)))

Submission status: Accepted

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

Submission status: Accepted

Solution code:
import numpy as np

a, b, x = map(int, input().split())
h = x / a ** 2
if 2 * h < b:
    c = 2 * x / (a * b)
    rad = np.arctan(b / c)
else:
    rad = np.arctan(2 * (b - h) / a)
print(rad * 180 / np.pi)

Submission status: Accepted

Solution code:
import math

a, b, x = (int(i) for i in input().split())
if x>=(a*a*b)/2:
    ta=(2*(a*a*b-x))/(a*a*a)
    print(math.degrees(math.atan(ta)))
else:
    ta=(2*x)/(a*b*b)
    print(90-math.degrees(math.atan(ta)))

Submission status: Accepted

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

Submission status: Accepted

Solution code:

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

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

Submission status: Accepted

Solution code:
import math
A, B, X = map(int, input().split())
S = X/A
pi = math.acos(-1)

if S > A*B/2:
    print(math.atan((A*B-S)*2/(A**2))*180/pi)
else:
    print(math.atan(B*B/2/S)*180/pi)

Submission status: Accepted

Solution code:
#!/usr/bin/env python
# -*- coding: utf-8 -*-
import math


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

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

  print(t * 180 / math.pi)


if __name__ == '__main__':
  main()

Submission status: Accepted

Solution code:
import sys
import math

input = sys.stdin.readline

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

if x>(a**2*b)/2.0:
	h = x/(a**2)
	sh = 2*h-b
	dh = b-sh

	theta = math.degrees(math.atan(dh/a))
else:
	h = (2.0*x)/(a*b)
	theta = math.degrees(math.atan(b/h))

print(theta)

Submission status: Accepted

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

Submission status: Accepted

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

Submission status: Accepted

Solution code:
import math

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

if x < a * a * b / 2:

	c1 = 2 * x / (b * a)
	
	r1 = math.atan2(b, c1) * 180.0 / math.pi

	print(r1)
else:

	c2 = (a * b - x / a) * 2 / a
	
	r2 = math.atan2(c2, a) * 180.0 / math.pi
	
	print(r2)

Submission status: Accepted

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

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

Submission status: Accepted

Solution code:
import math

a, b, x = map(float, input().split())
xx = x / (a**2)

if xx < b / 2:
	aa = ((a * xx) * 2) / b
	ans_2 = math.degrees(math.atan(aa/b))
	ans = 90 - ans_2
else:
	bb = b - xx
	aa = a / 2
	ans_2 = math.degrees(math.atan(bb/aa))
	ans = ans_2


print(ans)

Submission status: Accepted

Solution code:
import math
[a,b,X] = list(map(int,input().split()))
h = (X/a)/a
S = h*a
if S < a*b/2:
    c = 2*S/b
    output = math.degrees(math.atan(b/c))
else:
    c = 2*S/a - b
    output = math.degrees(math.atan((b-c)/a))
print(output)

Submission status: Accepted

Solution code:
import math

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

t = 2*x/(a*a)-b
if t >= 0 :
    print(math.degrees(math.atan2(2*b-2*x/(a*a), a)))
else :
    print(math.degrees(math.atan2(b, 2*x/(a*b))))

Submission status: Accepted

Solution code:
import math


def main():
    a, b, x = map(int, input().split())
    x /= a
    if x <= a * b / 2:
        c = x * 2 / b
        ans = math.atan2(b, c) * 360 / (math.pi * 2)
    else:
        y = a * b - x
        c = y * 2 / a
        ans = math.atan2(c, a) * 360 / (math.pi * 2)
    print(ans)


if __name__ == "__main__":
    main()

Submission status: Accepted

Solution code:
import queue
import math
"""
N = int(input())
#S = input()
# (N,M) = (int(i) for i in input().split(" "))
# A = [int(i) for i in input().split()]
A = []
for i in range(N):
	A.append(int(input()))

print(A)

"""
(a,b,x) = (int(i) for i in input().split(" "))
mn = 0
mx = 100
while mx-mn > .0000000001:
	md = (mx+mn)/2
	al = b/math.tan(md*math.pi/180)
	if al < a:
		n = a*al*b/2
	else:
		n=(b-b*a/al/2)*a*a
	if n < x:
		mx = md
	else:
		mn = md
print(md)

Submission status: Accepted

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

if a*b/2*a < v:
	tanres = (2*b-2*v/(a*a))/a
else:
	tanres = a*b*b/(2*v)
arc = math.atan(tanres)
deg = arc*180/math.pi
print('%.20f'%deg)

Submission status: Accepted

Solution code:
from math import atan2, degrees
A, B, X = map(int, input().split())
if X < A*A*B/2:
    theta = atan2(A*B*B, 2*X)
else:
    theta = atan2(2*(A*A*B-X),A**3)
print(degrees(theta))

Submission status: Accepted

Solution code:
from math import *
A, B, X = map(int, input().split())
X /= A
if A*B/2 > X:
    l = 2 * X / B
    print(degrees(atan(B/l)))
else:
    y = A * B - X
    l = 2 * y / A
    print(degrees(atan(l/A)))

Submission status: Accepted

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

if x <= a * a * b / 2:
    c = 2 * x / (a * b)
    ans = math.atan2(b, c)
    ans *= 360 / (2 * math.pi)
else:
    c = 2 * b - 2 * x / (a**2)
    ans = math.atan2(c, a)
    ans *= 360 / (2 * math.pi)

print(ans)

Submission status: Accepted

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

l = 2*h - b
c = 2 * a * h / b

if l >= 0:
    print("%.10f"%(180 / pi * atan((b-l)/a)))
else:
    print("%.10f"%(180 / pi * atan(b/c)))

Submission status: Accepted

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

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

Submission status: Accepted

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

Submission status: Accepted

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

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

print(ans)

Submission status: Accepted

Solution code:
import numpy as np

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

tot = a*a*b

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

Submission status: Accepted

Solution code:
import math

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

hanbun=x>(a*a*h/2)

if(hanbun):
    takasa=(x/a/a)*2-h
    katamuki=(h-takasa)/a
    print(math.degrees(math.atan(katamuki)))
else:
    haba=2*x/a/h
    print(math.degrees(math.atan(h/haba)))

Submission status: Accepted

Solution code:
import math

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

Submission status: Accepted

Solution code:
import math

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

s = x / a
t = s / a

if t * 2 > b:

    print (math.degrees(math.atan((b-t)/(a*0.5))))

else:

    tei = s * 2 / b

    print (math.degrees(math.atan(b / tei)))

Submission status: Accepted

Solution code:
import sys

stdin = sys.stdin

ni = lambda: int(ns())
na = lambda: list(map(int, stdin.readline().split()))
ns = lambda: stdin.readline().rstrip()  # ignore trailing spaces

a, b, x = na()
s = x/a
import math

if s <= a*b/2:
    aa = s*2/b
    print("{:.14f}\n".format(math.atan2(b, aa)/math.pi*180))
else:
    bb = (s-a*b/2)*2/a
    print("{:.14f}\n".format(math.atan2(b-bb, a)/math.pi*180))

Submission status: Accepted

Solution code:
import numpy as np

A, B, X = map(int, input().split())
if A**2*B/2 > X:
    d = X*2/B/A
    ans = np.arctan(B/d)/np.pi*180
else:
    d = X*2/A/A - B
    ans = np.arctan((B-d)/A)/np.pi*180
print(ans)

Submission status: Accepted

Solution code:

from collections import defaultdict,deque
import sys,heapq,bisect,math,itertools,string,queue,copy,time
sys.setrecursionlimit(10**8)
INF = float('inf')
mod = 10**9+7
eps = 10**-7
def inp(): return int(sys.stdin.readline())
def inpl(): return list(map(int, sys.stdin.readline().split()))
def inpl_str(): return list(sys.stdin.readline().split())

a,b,x = inpl()

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

Submission status: Accepted

Solution code:
from sys import stdin
from math import atan

def input():
    return stdin.readline()[:-1]


def intput():
    return int(input())


def sinput():
    return input().split()


def intsput():
    return map(int, sinput())


a, b, x = intsput()

if x / a > 0.5 * a * b:
    print(atan((2 * a ** 2 * b - 2 * x) / a ** 3) / 3.14159265358979 * 180)
else:
    print(atan(a * b ** 2 / 2 / x) / 3.14159265358979 * 180)

Submission status: Accepted

Solution code:
import math

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

Submission status: Accepted

Solution code:
import math
a, b, x = [int(i) for i in input().split()]
m = a * a * b
if x >= m/2:
    c = (m - x) * 2 / (a ** 2)
    print(math.atan2(c, a)/math.pi*180)
else:
    c = x * 2 / (a * b)
    print(math.atan2(b, c)/math.pi*180)

Submission status: Accepted

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


import sys
sys.setrecursionlimit(10**6)
readline = sys.stdin.readline 

from math import atan2, pi
#n = int(input())
a,b,x = [int(i) for i in readline().split()]

if a*a*b/2 > x:
    c = (x)*2/b/a
    print(atan2(b,c)*360/2/pi)

else:
    c = 2*(a*a*b-x)/a/a
    print(atan2(c,a)*360/2/pi)

Submission status: Accepted

Solution code:
import math
a, b, x = [int(i) for i in input().split()]
c = (2 * x / a**2 ) - b
if c <= 0:
    c = (2 * x) / (a * b)
    print(math.degrees(math.atan2(b, c)))
else:
    print(math.degrees(math.atan2(b - c, a)))

Submission status: Runtime Error

Solution code:
a,b,x = map(int,input().split())
from decimal import Decimal
if x>= (a**2)*b/2:
    tan = 2*(Decimal(a)*Decimal(a)*Decimal(b)-Decimal(x))/(Decimal(a)**3)
    import math
    answer = math.degrees(math.atan(tan))
else:
    pretan = 2*Decimal(x)/(Decimal(b)**2*Decimal(a))
    #answer = Decimal(90)-Decimal(math.degrees(math.atan(pretan)))
    answer = Decimal(90)*10**10-Decimal(math.degrees(math.atan(pretan)))*10**10
    answer /=  10**10
print(answer)

Submission status: Runtime Error

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

Submission status: Runtime Error

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

Submission status: Runtime Error

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

Submission status: Runtime Error

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

Submission status: Runtime Error

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

Submission status: Runtime Error

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

Submission status: Runtime Error

Solution code:
import numpy as np

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

if x < 1/2*a*b:
    a1 = 2*x/(a*b)
    rad = np.arctan(a1/b)
else:
    y = 2*(b-x/a**2)
    rad = np.arctan(a/y)

print(90-rad*180/np.pi)

Submission status: Runtime Error

Solution code:
import re
import sys
import math
import itertools
import bisect
from copy import copy
from collections import deque,Counter
from decimal import Decimal
import functools
def v(): return input()
def k(): return int(input())
def S(): return input().split()
def I(): return map(int,input().split())
def X(): return list(input())
def L(): return list(input().split())
def l(): return list(map(int,input().split()))
def lcm(a,b): return a*b//math.gcd(a,b)
sys.setrecursionlimit(10 ** 6)
mod = 10**9+7
cnt = 0
ans = 0
inf = float("inf")
al = "abcdefghijklmnopqrstuvwxyz"
AL = al.upper()

a,b,x = I()

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

Submission status: Runtime Error

Solution code:
import re
import sys
import math
import itertools
import bisect
from copy import copy
from collections import deque,Counter
from decimal import Decimal
import functools
def v(): return input()
def k(): return int(input())
def S(): return input().split()
def I(): return map(int,input().split())
def X(): return list(input())
def L(): return list(input().split())
def l(): return list(map(int,input().split()))
def lcm(a,b): return a*b//math.gcd(a,b)
sys.setrecursionlimit(10 ** 6)
mod = 10**9+7
cnt = 0
ans = 0
inf = float("inf")
al = "abcdefghijklmnopqrstuvwxyz"
AL = al.upper()

a,b,x = I()

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

Submission status: Runtime Error

Solution code:
import re
import sys
import math
import itertools
import bisect
from copy import copy
from collections import deque,Counter
from decimal import Decimal
import functools
def v(): return input()
def k(): return int(input())
def S(): return input().split()
def I(): return map(int,input().split())
def X(): return list(input())
def L(): return list(input().split())
def l(): return list(map(int,input().split()))
def lcm(a,b): return a*b//math.gcd(a,b)
sys.setrecursionlimit(10 ** 6)
mod = 10**9+7
cnt = 0
ans = 0
inf = float("inf")
al = "abcdefghijklmnopqrstuvwxyz"
AL = al.upper()

a,b,x = I()

if a**2*b == 2*x:
  print(90-180/math.pi*math.atan(a/b))
elif a**2*b < 2*x:
  ama = x-a**2*b*0.5
  ran = 2*ama/(a**2)
  print(90-180/math.pi*math.atan(a/(b-ran)))
else:
  ran = 2*x/(a*b)
  print(90-180/math.pi*math.atan(ran/b))

Submission status: Runtime Error

Solution code:
import re
import sys
import math
import itertools
import bisect
from copy import copy
from collections import deque,Counter
from decimal import Decimal
import functools
def v(): return input()
def k(): return int(input())
def S(): return input().split()
def I(): return map(int,input().split())
def X(): return list(input())
def L(): return list(input().split())
def l(): return list(map(int,input().split()))
def lcm(a,b): return a*b//math.gcd(a,b)
sys.setrecursionlimit(10 ** 6)
mod = 10**9+7
cnt = 0
ans = 0
inf = float("inf")
al = "abcdefghijklmnopqrstuvwxyz"
AL = al.upper()

a,b,x = I()

if a**2*b <= 2*x:
  ama = x-a**2*b*0.5
  ran = 2*ama/(a**2)
  print(90-180/math.pi*math.atan(a/(b-ran)))
else:
  ran = 2*x/(a*b)
  print(90-180/math.pi*math.atan(ran/b))

Submission status: Runtime Error

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

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

Submission status: Runtime Error

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

Submission status: Runtime Error

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

Submission status: Runtime Error

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

def get_angle_from_sides(a, b, c):
    return math.acos((a ** 2 + b ** 2 - c ** 2) / (2 * a * b))

def checkio(a, b, c):
    try:
        angles = [get_angle_from_sides(*abc) for abc in ((a, b, c), (b, c, a), (c, a, b))]
        result = sorted((math.degrees(a)) for a in angles)
        return [0, 0, 0] if 0 in result else result
    except ValueError:
        return [0, 0, 0]
count = 0
if y/2 <=x:
  if a>=2*(b-h):
    m = checkio(a,2*(b-h),math.sqrt(a**2+(2*(b-h))**2))
    count = m[0]
  elif a<2*(b-h):
    m = checkio(a,2*(b-h),math.sqrt(a**2+(2*(b-h))**2))
    count = m[1]
elif y/2>x:
  z = 2*x/(a*b)
  if b>=z:
    m = checkio(b,z,math.sqrt(b**2+(z)**2))
    count = m[1]
  elif b<z:
    m = checkio(b,z,math.sqrt(b**2+(z)**2))
    count = m[0]
#print(a,2*(b-h),math.sqrt(a**2+2*(b-h)**2),m)
print(count)

Submission status: Runtime Error

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

def get_angle_from_sides(a, b, c):
    return math.acos((a ** 2 + b ** 2 - c ** 2) / (2 * a * b))

def checkio(a, b, c):
    try:
        angles = [get_angle_from_sides(*abc) for abc in ((a, b, c), (b, c, a), (c, a, b))]
        result = sorted((math.degrees(a)) for a in angles)
        return [0, 0, 0] if 0 in result else result
    except ValueError:
        return [0, 0, 0]
count = 0
if y/2 <=x:
  if a>=2*(b-h):
    m = checkio(a,2*(b-h),math.sqrt(a**2+(2*(b-h))**2))
    count = m[0]
  elif a<2*(b-h):
    m = checkio(a,2*(b-h),math.sqrt(a**2+(2*(b-h))**2))
    count = m[1]
elif y/2>x:
  z = 2*x/(a*b)
  if b>=z:
    m = checkio(a,z,math.sqrt(a**2+(z)**2))
    count = m[1]
  elif b<z:
    m = checkio(a,z,math.sqrt(a**2+(z)**2))
    count = m[0]
    
print(count)

Submission status: Runtime Error

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

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

Submission status: Runtime Error

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

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

Submission status: Runtime Error

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

Submission status: Runtime Error

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

Submission status: Runtime Error

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

Submission status: Runtime Error

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

Submission status: Runtime Error

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

Submission status: Runtime Error

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

Submission status: Runtime Error

Solution code:
import math
A, B, X = map(int, input().split())
h = X / (A*A)
r = 0
deg = 0
if (2 * X) - (B * A * A) > 0:
  r = math.atan(2 * (B-H) / A)
elif (2 * X) - (B * A * A) == 0:
  r = math.atan(B / A)
else:
  h = (2 * X) / (A * B)
  r = math.atan(B / h)
deg = math.degrees(r)
print(deg)

Submission status: Runtime Error

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

Submission status: Runtime Error

Solution code:
import math

def main():
    a, b, x = map(int, input().split())
    mid = a**2*b/2
    c = x/(a**2)
    if mid == x:
        ans = 90 - math.degrees(math.atan(a/b))
    elif mid < x:
        d = 2*x/(a**2) - b
        ans = 90 - math.degrees(math.atan(a/(b-d)))
    else:
        d = 2*a*c/b
        ans = 90 - math.degrees(math.atan(d/b))

    print(ans)

if __name__ == "__main__":
    main()

Submission status: Runtime Error

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

S = a*b
s = x/a

if s >= S/2:
  em_s = S-s
  tan = (a**2)/(2*em_s)
  ans = math.degrees(math.atan(tan))
  print(90-ans)
else:
  tan = (2*s)/(b**2)
  ans = math.degrees(math.atan(tan))
  print(90-ans)

Submission status: Runtime Error

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

if x*2 >= V:
  print(math.degrees(math.atan(2*l/a**3)))
else:
  print(math.degrees(math.atan(V/2*x)))

Submission status: Runtime Error

Solution code:
import math

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

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

Submission status: Runtime Error

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

Submission status: Runtime Error

Solution code:
import math

def cin():
    in_ = list(map(int,input().split()))
    if len(in_) == 1:  return in_[0]
    else:  return in_

a, b, x = cin()

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

Submission status: Runtime Error

Solution code:
import math

a, b, x = cin()

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