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: Runtime Error

Solution code:
import math
a,h,x = [int(j) for j in input().split()]
y = (h*a - x/a)*(2/a**2)
print(90-math.degrees(math.atan(1/y)))

Submission status: Runtime Error

Solution code:
import math

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

q = a*b*b/2/x

print(math.degrees(math.atan(q))

Submission status: Runtime Error

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

Submission status: Runtime Error

Solution code:
import math

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

q = a*b*b/(2*x)

print(math.degrees(math.atan(q))

Submission status: Runtime Error

Solution code:
import math

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

q = (a*b*b)/(2*x)

print(math.degrees(math.atan(q))

Submission status: Runtime Error

Solution code:
import math


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

if 2*x<a*a*b:
    sit=math.acos(2*x/(a*b*b))
    print(math.degrees(sit))
elif x==a*a*b:
    print(0)
elif 2*x>a*a*b:
    p1=2*(a*a*b-x)
    p2=a*a*a
    sit=math.atan(p1/p2)
    print(math.degrees(sit))
else:
    print(45.00000)

Submission status: Runtime Error

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

if x >= (a**2)*b*1/2:
    y = (-1)*b + 2*x/(a**2)
    if y==0:
        print(45.0)
        exit()
    d = math.atan(a / (b-y))
else:
    y = 2*x/(a*b)
    d = math.atan(y/b)
print(90 - math.degrees(d))

Submission status: Runtime Error

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

bottle=(a**2)*b

if x <= bottle/2:
  # 半分以上傾ける場合
  soko=(x*2/b)/a
  
  #bに対してtangent(r)がsokoとなるrを求める
  r=90-(math.degrees(math.atan(soko/b)))
  
else:
  # 半分傾けられない場合
  takasa=((a**2)*b-x)*2/(a**2)
  
  #takasaに対してtangent(r)がaとなるrを求める
  r=90-(math.degrees(math.atan(a/takasa)))

print(r)

Submission status: Runtime Error

Solution code:
import math 

arr = input().split()
a = int(arr[0])
b = int(arr[1])
x = int(arr[2])
ans1 = 90-math.atan(a*a*a/(2.0*(b*a*a-x)))/math.acos(-1)*180
ans2 = math.atan(a*b*b/2/x)/math.acos(-1)*180

if ans1 <= 45.0:
    print (ans1)
else:
    print (ans2)

Submission status: Runtime Error

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

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

Submission status: Runtime Error

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

Submission status: Runtime Error

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

Submission status: Runtime Error

Solution code:
import math
from scipy import optimize


def f1(sita,b,x):
    return b**2/4*math.sin(2*sita)*(math.sin(2*sita)**2 + 1)-x


def resolve():
    a,b,x=map(int,input().split())
    xx=x/a
    if xx<a*b/2:
        ans = optimize.fsolve(f1,math.pi/2,args=(b,xx),epsfcn=10**-8)
        print(math.degrees(ans[0]))
        pass
    elif xx==a*b/2:
        print(45)
    else:
        ts=a**2/(a*b-xx)/2
        print(90-math.degrees(math.atan(ts)))
        pass

if __name__ == "__main__":
    resolve()

Submission status: Runtime Error

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

Submission status: Runtime Error

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)
    print(const.convToDEG*math.acos(h/b))

Submission status: Runtime Error

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

Submission status: Runtime Error

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

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

Submission status: Runtime Error

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

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

print(90-theta)

Submission status: Runtime Error

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

Submission status: Runtime Error

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

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

Submission status: Runtime Error

Solution code:
from collections import Counter,defaultdict,deque
import sys,bisect,math,itertools,string,queue
from heapq import heappop, heappush
sys.setrecursionlimit(10**8)
mod = 10**9+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())
def inpln(n): return list(int(sys.stdin.readline()) for i in range(n))

a,b,x = inpl()


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

Submission status: Runtime Error

Solution code:
import sys,math
def input():
    return sys.stdin.readline()[:-1]


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

t = x/(a**2)
half = b/2
if t<half:
    a_2 = x/b
    b_2 = b
else:
    a_2 = a
    b_2 = (b-t)*2
c = (a_2**2+b_2**2)**0.5
cos1 = (a_2**2+c**2-b_2**2)/(2*a*c)
print(math.degrees(math.acos(cos1)))

Submission status: Runtime Error

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

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

Submission status: Runtime Error

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

Submission status: Runtime Error

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

Submission status: Runtime Error

Solution code:
import sys
input = sys.stdin.readline
import math

def main():
    a, b, x = [int(x) for x in input().split()]
    b_now = x / (a * a)
    menseki = b_now * a
    ans_a = menseki * 2 / b

    if ans_a <= a:
        z = math.degrees(math.atan(ans_a / b))
        print(90 - z)
        exit()
    else:
        menseki = a * b - menseki
        ans_b = menseki * 2 / a
        z = math.degrees(math.atan(a / ans_b))
        print(90 - z)
        exit()



if __name__ == '__main__':
    main()

Submission status: Runtime Error

Solution code:
import sys
input = sys.stdin.readline
import math

def main():
    a, b, x = [int(x) for x in input().split()]
    b_now = x / (a * a)
    menseki = b_now * a
    ans_a = menseki * 2 / b

    # 三角形の場合
    if ans_a <= a:
        z = math.degrees(math.atan(ans_a / b))
        print(90 - z)
        exit()

    # 三角形 + 平行四辺形の場合
    else:
        menseki = a * b - menseki
        ans_b = menseki * 2 / a
        z = math.degrees(math.atan(a / ans_b))
        print(90 - z)
        exit()



if __name__ == '__main__':
    main()

Submission status: Runtime Error

Solution code:
import sys
import math


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

    s = x / a
    if s > a * b / 2:
        # ans = math.atan(1 / (2 / a * (b - s / a)))
        ans = math.atan(a ** 2 / (2 * (a * b - s)))
    else:
        ans = math.atan(2 * s / (b ** 2))

    print(90 - math.degrees(ans))


if __name__ == '__main__':
    main()

Submission status: Runtime Error

Solution code:
import math


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

if 2*x<a*a*b:
    sit=math.acos(2*x/(a*b*b))
    print(math.degrees(sit))
elif 2*x>a*a*b:
    p1=2*(a*a*b-x)
    p2=a*a*a
    sit=math.atan(p1/p2)
    print(math.degrees(sit))
else:
    print(45.00000)

Submission status: Runtime Error

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

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

Submission status: Runtime Error

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

Submission status: Runtime Error

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

Submission status: Runtime Error

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


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

Submission status: Runtime Error

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

Submission status: Runtime Error

Solution code:
def calc(a, b, x):
    if x > a * a * b / 2:
        y = 2 * (a * a * b - x) / a ** 3
        return m.degrees(m.atan(y))
    else:
        y = a * b * b / 2 / x
        return m.degrees(m.atan(y))


(a, b, x) = tuple([int(s) for s in input().split()])
print(calc(a, b, x))

Submission status: Runtime Error

Solution code:
import math


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

if x<=(a**2)*b/2:
    sit=math.acos(2*x/(a*b*b))
    print(math.degrees(sit))
else:
    p1=a*a*b-x
    p2=a*a*a/2
    #print((-p1+math.sqrt(p1*p1+4*p2*p2))/2)
    sit=math.atan(p1/p2)
    print(math.degrees(sit))

Submission status: Runtime Error

Solution code:
import numpy as np
a,b,x = map(int,input().split())
V = a * a * b
dV = V - x
#y = max(V,dV)
#h = dV / V * b * 2
#theta = np.arctan(a / h) * 360 / (2 * np.pi)

if x >= V / 2:
  h = dV / V * b * 2
  theta = np.arctan(a / h) * 360 / (2 * np.pi)
  print(90-theta)
else:
  h = x / V * a * 2
  theta = np.arctan(h / b) * 360 / (2 * np.pi)
  print(90-theta)

Submission status: Runtime Error

Solution code:
import math

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

    if x <= a*a*b*0.5:
        y = 2*x/(a*b)
        p = y/((b**2 + y**2)**0.5)
        ans = math.degrees(math.acos(p))
    else:
        k = (2*a*x - a*a*a*b)/(2*a*a*b -2*x)
        ans = math.degrees(math.atan(b/(a+k)))

    print(ans)

if __name__ == "__main__":
    main()

Submission status: Runtime Error

Solution code:
import sys
import math


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

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


if __name__ == '__main__':
    main()

Submission status: Runtime Error

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

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

else:
    theta = math.atan(2 * V / (a * b**2))

print(90 - theta * 180 / math.pi)

Submission status: Runtime Error

Solution code:
import math
a, b, x = map(int, input().split())
if a*a*b == x:
    print(0)
    exit()
if x <= (a*a*b)/2:
    n = (2*x)/(a*b)
    s = (n**2 + b**2)**0.5
    print(math.degrees(math.asin(b/s)))
elif 
    n = (2*x) / (a**2) - b
    a = (a*n) / (b-n) + a
    s = (a**2 + b**2)**0.5
    print(math.degrees(math.asin(b/s)))

Submission status: Runtime Error

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

Submission status: Runtime Error

Solution code:
import math

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

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

Submission status: Runtime Error

Solution code:
from decimal import *
import math

def main():
    a, b, x = map(int, input().split())
    if Decimal(a) * Decimal(b) / Decimal(2) >= Decimal(x) / Decimal(a):
        tmp = Decimal(2) * Decimal(x) / (Decimal(a) * Decimal(b))
        c = math.atan(Decimal(tmp) / Decimal(b))
        d_deg = math.degrees(Decimal(c))
        print(Decimal(90) - Decimal(d_deg))
    else:
        d = (Decimal(2) * Decimal(x) / (Decimal(a) * Decimal(a))) - Decimal(b)
        c = math.atan(Decimal(a) / (Decimal(b) - Decimal(d)))
        d_deg = math.degrees(Decimal(c))
        print(Decimal(90) - Decimal(d_deg))


if __name__ == "__main__":
    main()

Submission status: Runtime Error

Solution code:
# D
import sys
import math


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

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


if __name__ == '__main__':
    main()

Submission status: Runtime Error

Solution code:
import math
a, b, x = map(int,input().split())
sita = 0
c = 0
if a*a*b/2 <= x:
  c = a*a*a/2/(a*a*b-x)
  sita = math.atan(c)
else:
  c = 2*x/a/b/b
  sita = math.atan(c)
print('{:.10g}'.format(90-math.degrees(sita)))

Submission status: Runtime Error

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

halfVolume=a*a*b/2

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

else:
    h=x/(a*b)
    print(const.convToDEG*math.acos(2*h/b))

Submission status: Runtime Error

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

all_v = a*a*b
#h = x/(a*a)

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

Submission status: Runtime Error

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

Submission status: Runtime Error

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

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

Submission status: Runtime Error

Solution code:
import math
A, B, X = map(int, input().split())

C = A**3/(2*(A*A*B-X))

S = math.degrees(math.atan(C))

print(90-S)

Submission status: Runtime Error

Solution code:
use std::io::*;
use std::str::FromStr;

pub fn read<T: FromStr>() -> T {
    let stdin = stdin();
    let stdin = stdin.lock();
    let token: String = stdin
        .bytes()
        .map(|c| c.expect("failed to read char") as char)
        .skip_while(|c| c.is_whitespace())
        .take_while(|c| !c.is_whitespace())
        .collect();
    token.parse().ok().expect("failed to parse token")
}

pub fn read_n<T: FromStr>(n: usize) -> Vec<T> {
    read_n_logic::<T>(n, vec![])
}

pub fn read_n_logic<T: FromStr>(n: usize, mut a: Vec<T>) -> Vec<T> {
    match n {
        0 => a,
        _ => {
            a.push(read::<T>());
            read_n_logic(n - 1, a)
        }
    }
}

use std::cmp::{max, min};

fn main() {
    let a: f64 = read();
    let b: f64 = read();
    let x: f64 = read();

    if (a * a * b) - x < (a * a * b / 2.0) {
        let ans = (2.0 * ((a * a * b) - x)) / (a * a * a);
        let abs_difference = ans.atan().to_degrees();
        println!("{}", abs_difference);
    } else {
        let ans = (a - (a - ((2.0 * x) / (a * b)))) / b;
        let abs_difference = ans.atan().to_degrees();
        println!("{}", 90.0 - abs_difference);
    }
}

Submission status: Runtime Error

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

halfVolume=a*a*b/2
print(halfVolume)

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

else:
    h=x/(a*b)
    print(const.convToDEG*math.acos(2*h/b))

Submission status: Runtime Error

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

Submission status: Runtime Error

Solution code:
import math


def main():
    a, b, x = map(int, input().split())
    y = x / a
    s = a * b
    if y >= s / 2:
        y = (a * b) - (x / a)
        # a, b = b, a
        b_temp = 2 * y / a
        angle = math.atan(a / b_temp)
        print(90 - math.degrees(angle))
    else:
        a_temp = 2 * y / b
        angle = math.atan(b / a_temp)
        print(math.degrees(angle))



if __name__ == '__main__':
    main()

Submission status: Runtime Error

Solution code:
import sys
import math
a, b, x = map(int, sys.stdin.readline().strip().split())

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

Submission status: Runtime Error

Solution code:
import math

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

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

Submission status: Runtime Error

Solution code:
import math

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

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

Submission status: Runtime Error

Solution code:
import math
a=int(input(""))
b=int(input(""))
x=int(input(""))
c=a**2
d=c*b-x
e=2*d/c
f=math.sqrt(a**2+e**2)
g=e/f
h= math.degrees(math.asin(g))
print(h)

Submission status: Runtime Error

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

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

Submission status: Runtime Error

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

if abs(((a**2) * b) / 2 - x) < 1e-5:
    print(45)
elif ((a**2) * b) / 2 < x:
    atan = math.degrees(math.atan((a**3)/(2*b*(a**2) - 2*x)))
    print(90-atan)
else:
    atan = math.degrees(math.atan((2*x)/(a*(b**2))))
    print(90-atan)

Submission status: Runtime Error

Solution code:
from math import degrees, atan, sqrt, tan

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

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

Submission status: Runtime Error

Solution code:
from math import atan, degrees

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

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

Submission status: Runtime Error

Solution code:
import math

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

y = b - (x / a**2)
z = (4 * y**2 + a**2)**0.5

cos = (a**2 - 4*y**2 - z**2) / (-4 * y * z)

theta = math.degrees(math.acos(cos))

print(90 - theta)

Submission status: Runtime Error

Solution code:
from math import atan, degrees

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

    t = atan(a**3 / (2 * a**2 * b - 2 * x))
    s = atan(2 * x / (a * b**2))

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


if __name__ == "__main__":
    main()

Submission status: Runtime Error

Solution code:
a,b,c = map(int,input().split())
L = a**2*b
l = L/2
# print(L,l)
# if l:
#     print(0)
#     exit()
if L  == c:
    print(0)
    exit()
if c <= l:
    t = 2*c/(a*b)
    T = t/b
    # print(t,T)
    atan1 = math.degrees(math.atan(T))
    print(90-atan1)
else:
    x = 2*c/a**2 - b
    t = a/(b-x)
    atan1 = math.degrees(math.atan(t))
    print(90-atan1)

Submission status: Runtime Error

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

Submission status: Runtime Error

Solution code:
import numpy as np

def main():
	A, B, X = [int(x) for x in input().split()]

	if (A * A * B) / 2.0 >= X:
		y = (2 * X) / (A * B)
		R = np.arctan(y / B)
		print(90 - np.rad2deg(R))
	else:
		_x = (A * A * B) - X
		y = (2 * _x) / (A * A)
		R = np.arctan(A / y)
		print(90 - np.rad2deg(R))
	
if __name__ == "__main__":
	main()

Submission status: Runtime Error

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

Submission status: Runtime Error

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

Submission status: Runtime Error

Solution code:
# -*- coding: utf-8 -*-
from math import ceil, sqrt, atan, degrees

def solve():
    a,b,x = map(int, input().split())
    if 1/2*a*a*b >= x:
        t = atan(2*x/a/b/b)
    else:
        t = atan(a*a*a/2/(a*a*b-x))

    return str(90-degrees(t))
        
if __name__ == '__main__':
    print(solve())

Submission status: Runtime Error

Solution code:
import math
from sympy import *
a,b,X = map(float,input().split())
T = math.atan(a/b)
if X <= a**2*b/2.0:
    c = 2*X/(a*b**2)
    t = Symbol('t', real=True)
    x = solve(t**3-c*t**2+t-c)[0]
    theta = 90.0 -math.atan(x)*180/math.pi
else:
    Y = a**2*b-X
    theta = math.atan(2*Y/a**3)*180/math.pi
print(theta)

Submission status: Runtime Error

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

Submission status: Runtime Error

Solution code:
# coding: utf-8
import math

a, b, x = [int(y) for y in input().split(" ")]

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

Submission status: Runtime Error

Solution code:
a,b,x=map(int,input().split())
if x<a*a*b//2:
    q=math.degrees(math.atan(a*b*b/(2*x)))
else:
    q=math.degrees(math.atan(2*(a*a*b-x)/(a**3)))
print('{:.10f}'.format(q))

Submission status: Runtime Error

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

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

Submission status: Runtime Error

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

if a*a*b*0.5 == x:
  print(45)
elif a*a*b*0.5 < x:
  volume = a*a*b - x
  val = 2*volume/(a*a*a)
  print(volume,val)
  print(math.degrees(math.asin(val)))

else:
  volume = x
  val = 2*volume/(a*b*b)
  print(90-math.degrees(math.asin(val)))

Submission status: Runtime Error

Solution code:
a,b,x = list(map(int,input().split()))
from math import acos
from math import sqrt
from math import degrees
if (x/(a*a))*2 <= b:
    S = x/a
    y = 2*x/(a*b)
    c = sqrt(y*y + b * b)
    z = (b*b + c*c - y*y)/(2*c)
    theta = degrees(acos(z/b))
else:
    S = x/a
    y = (2*S)/a - b
    y = b - y
    c = sqrt(a * a + y * y)
    z = (y*y - a*a + c*c)/(2*c)
    theta = degrees(acos(z/y))
print(90-theta)

Submission status: Runtime Error

Solution code:
import math
a,b,c = map(int,input().split())
L = a**2*b
l = L/2
# print(L,l)

if c <= l:
    t = 2*c/(a*b)
    T = t/b
    # print(t,T)
    atan1 = math.degrees(math.atan(T))
    print(90-atan1)
else:
    x = 2*c/a**2 - b
    t = a/(b-x)
    atan1 = math.degrees(math.atan(t))
    print(90-atan1)

Submission status: Runtime Error

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

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

Submission status: Runtime Error

Solution code:
import math

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

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

Submission status: Runtime Error

Solution code:
import numpy as np

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

xlim = a*b/2*a
if x<xlim:
    theta = np.arctan(a*b*b/2/x)/np.pi*180
else:
    theta = np.arctan(2*(a*a*b-x)/a**3)/np.pi*180

print(theta)

Submission status: Runtime Error

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

Submission status: Runtime Error

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

Submission status: Runtime Error

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

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

Submission status: Runtime Error

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

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

Submission status: Runtime Error

Solution code:
import math

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

t = a*a*b

if x <= t*0.5:
    tan = 2*x/(a*b*b)
    theta = math.degrees(math.atan(tan))
else:
    tan = a*a*a/(2*(a*a*b - x))
    theta = math.degrees(math.atan(tan))

print(90 - theta)

Submission status: Runtime Error

Solution code:
import math
from fractions import Fraction

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

y = Fraction(x / (a ** 2))

if b > a:
    a = Fraction(2 * a * y / b)
    teihen = b
else:
    teihen = 2 * (b - y)
res = Fraction(a / teihen)
print(90 - math.degrees(math.atan(res)))

Submission status: Runtime Error

Solution code:
import sys, math

def input(): return sys.stdin.readline()[:-1]
def ceil(x, y=1): return int(-(-x // y))
def INT(): return int(input())
def MAP(): return map(int, input().split())
def LIST(): return list(map(int, input().split()))
def MATINT(h): return [list(map(int, input().split())) for _ in range(h)]
def MATSTR(h): return [input() for _ in range(h)]
sys.setrecursionlimit(10 ** 9)
inf = float('inf')
mod = 10 ** 9 + 7

A, B, X = MAP()
V = A* A * B - X
if V < X:
    # Y = 2 * vacant / A / A
    ans = 90 - math.degrees(math.atan(A**3 / (2*V)))
else:
    # Y = 2 * X / A / B
    ans = 90 - math.degrees(math.atan(2 * X / (A*B*B)))
print(ans)

Submission status: Runtime Error

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

Submission status: Runtime Error

Solution code:
import math
a,b,v=map(int,input().split())
theta1=0
theta2=math.pi/2
ans=10**9
if a*a*b/2>=v:
    while 1:
        tmp=math.tan((theta1+theta2)/2)-2*v/(a*b*b)
        if abs(tmp)<=10**(-6):
            ans=(theta1+theta2)/2
            break
        else:
            if tmp>0:
                theta2=(theta1+theta2)/2
            else:
                theta1=(theta1+theta2)/2
else:
    while 1:
        tmp=math.tan((theta1+theta2)/2)-(a**3)/(2*(a*a*b-v))
        if abs(tmp)<=10**(-6):
            ans=(theta1+theta2)/2
            break
        else:
            if tmp>0:
                theta2=(theta1+theta2)/2
            else:
                theta1=(theta1+theta2)/2
print(90-math.degrees(ans))

Submission status: Runtime Error

Solution code:
#!/usr/bin/env python3
import sys
args = sys.argv
if len(args) == 2:
  from IPython import embed
  em = True
else:
  em = False
input = sys.stdin.readline
a, b, x = map(int, input().split())
import math
if 2*x/b <= a:
  ans = math.degrees(math.atan(a*b**2/(2*x)))
else:
  ans = 90 - math.degrees(math.atan(a/(2*b - 2*x/(a**2))))
print(ans)
if em: sys.stdin = open('/dev/tty')

Submission status: Runtime Error

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

print(90-math.degrees(z))

Submission status: Runtime Error

Solution code:
import sys
import math
a, b, x = [float(i) for i in sys.stdin.readline().split()]
if x < a**2*b / 2:
    print(90.0 - math.degrees(math.atan(x / (a*b**2/2))))
else:
    print(90.0 - math.degrees(math.atan(a**3 / 2 / (a**2*b-x))))

Submission status: Runtime Error

Solution code:
import math 
A,B,X = map(int,input().split())

t = 0
if (A**2)*B/X >= 2:
    t = float((A*(B**2))/(2*X))
else:
    t = float((A**3)/(2*(A**2)*B-2*X))

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