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, b, x = map(int, input().split())
if (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: Runtime Error

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

Submission status: Runtime Error

Solution code:
a,b,x=map(int,input().split())
v=a*a*b/2
k=(v-x)/(a*b)
g=x/(a*b)
if x<=v:
  print(math.atan(b/g)*180/math.pi)
else:
  print(math.atan(b/k)*180/math.pi)

Submission status: Runtime Error

Solution code:
import math

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

sakaime = a * a * b / 2

if x > sakaime:
    tan = a / (2 * (b - (x / (a ** 2))))
else:
    tan = 2 * x / (a * (b**2))

ans = math.degrees(math.atan(tan))

if ans >= 0:
    print(90-ans)

Submission status: Runtime Error

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

Solution code:
a,b,x = map(int,input().split())
S = x/a
if S <= a*b/2:
    theta = np.rad2deg(np.arctan(b*b/(2*S)))
else:
    S = a*b-S
    theta = np.rad2deg(np.arctan(2*S/(a*a)))
print(theta)

Submission status: Runtime Error

Solution code:
import math

a, b, water = map(int, input().split())
pool = a ** 2 * b

if water > pool / 2:
    high = 2 * (pool - water) / (a ** 2)
    ans = 90 - math.degrees(math.atan(a / high))
elif water == pool / 2:
    ans = 45
else:
    high = 2 * water / (a * b)
    ans = 90 - math.degrees(math.atan(high / b))

print(ans)

Submission status: Runtime Error

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

Submission status: Runtime Error

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 = atan2(b, a)
else:
	arg = (a * (b ** 2)) / (2 * x)

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

Submission status: Runtime Error

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

Solution code:
a,b,x=map(int,input().split())
import math
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: Runtime Error

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

Submission status: Runtime Error

Solution code:
from math import atan
a,b,x=map(int, input().split())
ans=None
V=(a**2)*b
if x>=V/2:
  #S=(x/a**2*b)*a*b
  #S=0.5*a*y
  #y=2S/a
  #tan(ans)=y/a
  #atan(y/a)=ans
  S=(x/a**2*b)*a*b
  y=2S/a
  ans=atan(y/a)
else:
  #S=(x/a**2*b)*a*b
  #S=0.5*b*y
  #y=2S/b
  #ans=90-atan(y/b)
  S=(x/a**2*b)*a*b
  y=2S/b
  ans=90-atan(y/b)
  
print(ans)

Submission status: Runtime Error

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

Submission status: Runtime Error

Solution code:
import math
def main():
    a, b, x = map(float, input().split())
    thX = a * a * b / 2.0
    if x <= thX:
        h = 2.0 * x / (a * b)
        deg = math.degrees(math.atan(h / b))
        print(90.0 - deg)
    else:
        c = 2.0 * x / (a*a) - b
        deg = math.degrees(math.atan(a / (b-c)))
        print(90 - deg)

main()

Submission status: Runtime Error

Solution code:
import math

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

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

Submission status: Runtime Error

Solution code:
import math

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

def calc_theta(a, b, x):
    if x >= 0.5 * a ** 2 * b:
        tmp = (a ** 3) / (2 * ((a **2) * b - x))
    else:
        tmp = (2 * x) / ((b ** 2) * a)

    return 90 - math.degrees(math.atan(tmp))

ans = calc_theta(a, b, x)

print('{:.10f}'.format(ans))

Submission status: Runtime Error

Solution code:
import math

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

def calc_theta(a, b, x):
    if x >= 0.5 * a ** 2 * b:
        tmp = (a ** 3) / (2 * ((a **2) * b - x))
    else:
        tmp = (2 * x) / ((b ** 2) * a)

    return 90 - math.degrees(math.atan(tmp))

ans = calc_theta(a, b, x)

print(ans)

Submission status: Runtime Error

Solution code:
import math

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

def calc_theta(a, b, x):
    if x > 0.5 * a ** 2 * b:
        tmp = (a ** 3) / (2 * ((a **2) * b - x))
    else:
        tmp = (2 * x) / ((b ** 2) * a)

    return 90 - math.degrees(math.atan(tmp))

ans = calc_theta(a, b, x)

print(ans)

Submission status: Runtime Error

Solution code:
import math

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

def calc_theta(a, b, x):
    if x > 0.5 * a ** 2 * b:
        tmp = (a ** 3) / (2 * (a **2 * b - x))
    else:
        tmp = (2 * x) / (a ** 2 * b)
    return 90 - math.degrees(math.atan(tmp))

ans = calc_theta(a, b, x)

print(ans)

Submission status: Runtime Error

Solution code:
import math

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

def calc_theta(a, b, x):
    tmp = (a ** 3) / (2 * (a **2 * b - x))
    tmp2 = (2 * x) / (a ** 2 * b)
    return 90 - math.degrees(math.atan(tmp)), 90 - math.degrees(math.atan(tmp2))

ans1, ans2 = calc_theta(a, b, x)

if ans2 > 45:
    print(ans2)
else:
    print(ans1)

Submission status: Runtime Error

Solution code:
import math

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

def calc_theta(a, b, x):
    tmp = (a ** 3) / (2 * (a **2 * b - x))
    tmp2 = (2 * x) / (a ** 2 * b)
    return 90 - math.degrees(math.atan(tmp)), 90 - math.degrees(math.atan(tmp2))

ans1, ans2 = calc_theta(a, b, x)

print(ans1, ans2)

if ans2 > 45:
    print(ans2)
else:
    print(ans1)

Submission status: Runtime Error

Solution code:
import math

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

def calc_theta(a, b, x):
    tmp = (a ** 3) / (2 * (a **2 * b - x))
    tmp2 = (2 * x) / (a ** 2 * b)
    return 90 - math.degrees(math.atan(tmp)), 90 - math.degrees(math.atan(tmp2))



ans1, ans2 = calc_theta(a, b, x)

if ans2 > ans1:
    print(ans2)
else:
    print(ans1)

Submission status: Runtime Error

Solution code:
import math

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

def calc_theta(a, b, x):
    tmp = (a ** 3) / (2 * (a **2 * b - x))
    tmp2 = (2 * x) / (a ** 2 * b)
    return 90 - math.degrees(math.atan(tmp)), 90 - math.degrees(math.atan(tmp2))



 ans1, ans2 = calc_theta(a, b, x)

if ans2 > ans1:
    print(ans2)
else:
    print(ans1)

Submission status: Runtime Error

Solution code:
import math

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

Submission status: Runtime Error

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

Submission status: Runtime Error

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

Submission status: Runtime Error

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

Submission status: Runtime Error

Solution code:
import math

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

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

Submission status: Runtime Error

Solution code:
#D
import math
a,b,x=map(int,input().split())
cap=a**2*b
ans=0
if x>cap/2:
    n=2*x/(a*b)
    ans=math.atam(b/n)*180/math.pi
else:
    n=2*x/(a**2)
    ans=math.atan(n/a)*180/math.pi
print(ans)

Submission status: Runtime Error

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

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

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

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

Submission status: Runtime Error

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

# 台形の場合
if 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: Runtime Error

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

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

Submission status: Runtime Error

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

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

Submission status: Runtime Error

Solution code:
import sys

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

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

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

Submission status: Runtime Error

Solution code:
import sys
import os


def main():
    if os.getenv("LOCAL"):
        sys.stdin = open("input.txt", "r")

    N = int(sys.stdin.readline().rstrip())

    ret = float('inf')
    for i in range(1, 10000000):
        q, mod = divmod(N, i)
        if mod == 0:
            j = N // i
            ret = min(ret, ((j-1)+(i-1)))

    print(ret)


if __name__ == '__main__':
    main()

Submission status: Runtime Error

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

import numpy as np
if x>a*a*b/2:#半分よりも多い場合
    theta=np.arctan(2*(a*a*b)/a*a*a)
else:#半分に満たない場合
    theta=np.arctan((a*b*b)/(2*x))
theta = theta * 180 / np.pi
print(theta)

Submission status: Runtime Error

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

Submission status: Runtime Error

Solution code:
import math
from decimal import *

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


if __name__ == "__main__":
    main()

Submission status: Runtime Error

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

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

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
        # になるはずなのになぜかこれが間違ってるとか言われるし実際なんかしらんけどサンプル3が通らん
        s2 = (b * b / math.tan(math.radians(theta))) / 2.0
        if (x / a) + s2 < a * b:
            l = theta
        else:
            r = theta
    print("whyyyyyyyyyyyyyy")
    print(2 / 0)
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: Runtime Error

Solution code:
import math
a,b,x = map(int,input().split())
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: Runtime Error

Solution code:
import numpy as np
a, b, x = map(int, print().split())
print(np.rad2deg(np.arcsin((2*(x-(a*b))/(np.power(a, 2))))

Submission status: Runtime Error

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(np.arctan(Z)*180/(np.pi))
else:
    A = a*a*b-x
    B = (a*a)/A
    Z = B
    print(np.arctan(Z)*180/np.pi)

Submission status: Runtime Error

Solution code:
import math
a,b,x = map(int,input().split())
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: Runtime Error

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

Submission status: Runtime Error

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

import math

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

Solution code:
n = int(input())
f = 1
for i in range(1, int(n**.5)+1):
    if n % i == 0:
        f = i
print(f-1+n//f-1)

Submission status: Runtime Error

Solution code:
import math

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


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

Submission status: Runtime Error

Solution code:
import sys
sys.setrecursionlimit(4100000)

import logging
import math

logging.basicConfig(level=logging.DEBUG)

logger = logging.getLogger(__name__)


def resolve():
    a, b, x = [float(x) for x in sys.stdin.readline().split()]

    logger.debug([a, b, x])

    y_0 = 2 * x / a**2
    logger.debug(y_0)

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


if __name__ == "__main__":
    resolve()

# AtCoder Unit Test で自動生成できる, 最後のunittest.main は消す
# python -m unittest template/template.py
# pypy3 -m unittest template/template.py
import sys
from io import StringIO
import unittest


class TestClass(unittest.TestCase):
    def assertIO(self, input, output):
        stdout, stdin = sys.stdout, sys.stdin
        sys.stdout, sys.stdin = StringIO(), StringIO(input)
        resolve()
        sys.stdout.seek(0)
        out = sys.stdout.read()[:-1]
        sys.stdout, sys.stdin = stdout, stdin
        self.assertEqual(out, output)

    def test_入力例_1(self):
        input = """2 2 4"""
        output = """45.0000000000"""
        self.assertIO(input, output)

    def test_入力例_2(self):
        input = """12 21 10"""
        output = """89.7834636934"""
        self.assertIO(input, output)

    def test_入力例_3(self):
        input = """3 1 8"""
        output = """4.2363947991"""
        self.assertIO(input, output)

Submission status: Runtime Error

Solution code:
import sys
sys.setrecursionlimit(4100000)

import logging
import math

logging.basicConfig(level=logging.DEBUG)

logger = logging.getLogger(__name__)


def resolve():
    a, b, x = [float(x) for x in sys.stdin.readline().split()]

    logger.debug([a, b, x])

    y_0 = 2 * x / a**2
    logger.debug(y_0)

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


if __name__ == "__main__":
    resolve()

# AtCoder Unit Test で自動生成できる, 最後のunittest.main は消す
# python -m unittest template/template.py
# pypy3 -m unittest template/template.py
import sys
from io import StringIO
import unittest


class TestClass(unittest.TestCase):
    def assertIO(self, input, output):
        stdout, stdin = sys.stdout, sys.stdin
        sys.stdout, sys.stdin = StringIO(), StringIO(input)
        resolve()
        sys.stdout.seek(0)
        out = sys.stdout.read()[:-1]
        sys.stdout, sys.stdin = stdout, stdin
        self.assertEqual(out, output)

    def test_入力例_1(self):
        input = """2 2 4"""
        output = """45.0000000000"""
        self.assertIO(input, output)

    def test_入力例_2(self):
        input = """12 21 10"""
        output = """89.7834636934"""
        self.assertIO(input, output)

    def test_入力例_3(self):
        input = """3 1 8"""
        output = """4.2363947991"""
        self.assertIO(input, output)


if __name__ == "__main__":
    unittest.main()

Submission status: Runtime Error

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

x = x / a

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

Submission status: Runtime Error

Solution code:
import math
from math import atan, cos, tan

a, b, x = map(int, input().split()  ) #split()で分解したものを別々の変数に入れる

result =0

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

print(result)

Submission status: Runtime Error

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

Submission status: Runtime Error

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

Submission status: Runtime Error

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

Submission status: Runtime Error

Solution code:
import math

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

xdash = x / a
FULL = a * b

if FULL / 2 == xdash:
    print(math.degrees(math.atan2(b,a)))
elif FULL / 2 > xdash:
    print(90-math.degrees(math.atan(2*xdash/b/b)))
else:
    print(90-math.degrees(math.atan(a*a/2/(a*b-xdash))))

Submission status: Runtime Error

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

Submission status: Runtime Error

Solution code:
import numpy as np

a, b, x = map(float, input().split(" "))
print(np.arctan(2 / a * (b - x / (a ** 2)) / np.pi * 180)

Submission status: Runtime Error

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

Submission status: Runtime Error

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

Submission status: Runtime Error

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

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((a**3)/(2*((a**2)*b-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())
cap=a**2*b
y=((cap-x)*2)/a**2

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

Submission status: Runtime Error

Solution code:
import math

input_data = list(map(int(input().split)))
volume = input_data[2] ** 2
c = volume / input_data[0] / input_data[1]
deg = math.atan2(c, input_data[1])
print(deg)

Submission status: Runtime Error

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

Submission status: Runtime Error

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

Submission status: Runtime Error

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

Submission status: Runtime Error

Solution code:
import fractions

a, b, x = map(int, input().split())
s1 = fractions.degrees(fractions.atan(2*b/a - 2*x/(a*a*a)))
s2 = 90 - fractions.degrees(fractions.atan(2 * x / (a * b * b)))

if(a*a*b/2 <= x):
    print(s1)
else:
    print(s2)

Submission status: Runtime Error

Solution code:
import sympy
import math
x=sympy.Symbol("x")
a=input()
b=a.split()
c=list(map(int,b))
v=c[0]*c[0]*c[1]
if c[2]>=v/2:
    l=sympy.solve((c[0]**2)*x/2+(c[0]**2)*c[1]/2-c[2])
    print(math.degrees(math.atan2(c[0],c[1]-l[0])))
else:
    l=sympy.solve(c[0]*x*c[1]/2-c[2])
    print(math.degrees(math.atan2(l[0],c[1])))

Submission status: Runtime Error

Solution code:
import sympy
import math
x=sympy.Symbol("x")
a=input()
b=a.split()
c=list(map(int,b))
v=a*a*b
if x>=v/2:
    l=sympy.solve((c[0]**2)*x/2+(c[0]**2)*c[1]/2-c[2])
    print(math.degrees(math.atan2(c[0],c[1]-l)))
else:
    l=sympy.solve((c[0]*x*c[1]/2-c[2])
    print(math.degrees(math.atan2(l,c[1])))

Submission status: Runtime Error

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

Submission status: Runtime Error

Solution code:
import sympy
import math

t=sympy.Symbol('t')
n=input()
n=n.split()
a=int(n[0])
b=int(n[1])
x=int(n[2])
pi=math.pi

s=a*a
maxl=s*b
seg=maxl-x
unchi=2*seg/(a*s)
ans=sympy.solve((2*seg/(a*s))-(sympy.tan(t)))
print(ans[0]/pi*180)

Submission status: Runtime Error

Solution code:
# -*- coding: utf-8 -*-

import math

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

V = a**2 * b
V_2 = V / a

x_2 = x / a

if x_2 > V_2/2:
    c = 2*x/a**2 - b
    theta = math.atan(a/(b-c))
    deg = math.degrees(theta)
else:
    c = 2*x/(a*b)
    theta = math.atan(c/b)
    deg = math.degrees(theta)

print("{}".format(90.0-deg))

Submission status: Runtime Error

Solution code:
# -*- coding: utf-8 -*-

import math

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

V = a**2 * b
V_2 = V / a

x_2 = x / a

if x_2 > V_2/2:
    c = 2*x/a**2 - b
    theta = math.atan(a/(b-c))
    deg = math.degrees(theta)
else:
    c = 2*x/(a*b)
    theta = math.atan(c/b)
    deg = math.degrees(theta)

print("{:.9}".format(90-deg))

Submission status: Runtime Error

Solution code:
import numpy as np

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

bottom = 2 * x / a**2 - b
if bottom > 0:
    tan =  a / (b -  bottom)
    
else:
    bottom = 2 / (a * b) * x
    tan = bottom / b
    
theta = np.arctan(tan)
ret = 90 - np.rad2deg(theta)

print(ret)

Submission status: Runtime Error

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

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

Submission status: Runtime Error

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

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

Submission status: Runtime Error

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

Submission status: Runtime Error

Solution code:
def solve(N):
    ans = []
    for i in range(1, int(N**0.5)):
        if N % i == 0:
            ans.append(i+N//i-2)
    return min(ans)

N = int(input())
ans = solve(N)
print(ans)

Submission status: Runtime Error

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

half = a*a*b/2

from math import atan,pi
if x <= half:
    c = 2*x/a/b
    ans = atan(c/b)
else:
    c = 2*x/a/a - b
    ans = atan(a/(b-c))
print(90-ans*180/pi)

Submission status: Runtime Error

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

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

Submission status: Runtime Error

Solution code:
//#pragma comment(linker, "/stack:200000000")
#pragma GCC optimize("Ofast,no-stack-protector") 
//#pragma GCC optimize("Ofast")
//#pragma GCC target("sse,sse2,sse3,ssse3,sse4,popcnt,abm,mmx,avx,tune=native")
//#pragma GCC optimize("unroll-loops")

#include <bits/stdc++.h>


#define ll long long
#define int ll
#define ull unsigned long long
#define ld long double
#define rep(i, l, r) for (int i = l; i < r; i++)
#define repb(i, r, l) for (int i = r; i > l; i--)
#define sz(a) (int)a.size()
#define fi first
#define se second
#define all(x) x.begin(),x.end()
#define pb push_back
#define mp(a, b) make_pair(a, b)
#define ret(a) {cout << a; exit(0);}

using namespace std;

mt19937 mrand(random_device{}()); 
const ll mod=1000000007;
int rnd(int x) { return mrand() % x;}
ll powmod(ll a,ll b,ll mod) {ll res=1;a%=mod; assert(b>=0); for(;b;b>>=1){if(b&1)res=res*a%mod;a=a*a%mod;}return res;}

typedef pair < int , int > pii ;
typedef pair < long long  , long long > pll ;

const int N = 2e5 + 1;

int n, m, k;
int a[N];
string s;
bool was[N];
main(){
	ios::sync_with_stdio(0); cin.tie(0);cout.tie(0);
	ld a , b , x;
	cin >> a >> b >> x;	
	cout << setprecision(9) << fixed;
	ld y = 2.0 * x / (b * a);
	if(y <= a){
		ld alfa = atan(y / b);
		ld beta = 180.0 * alfa / acos(-1.0);
		cout << 90.0 - beta;
	}
	else{
		ld y = 2 * (a*a*b-x) / (a * a);
		ld alfa = atan(y / a);
		ld beta = 180.0 * alfa / acos(-1.0);
		cout << beta;
	}
}

Submission status: Runtime Error

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

Submission status: Runtime Error

Solution code:
n=int(input())
p=[]
total=0
for i in range(n,0,-1):
    p.append(i)
p.reverse()
for i in range(1,n):
    total+=i%p[i]
print(total)

Submission status: Runtime Error

Solution code:
import math

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

area_base = a ** 2
volum_bottle = area_base * b

k = 2 * (volum_bottle - x) / a ** 2

if k <= b:
  K_t = k / a
  angle = math.degree(math.atan(K_t))
else:
  L_t = a * (b ** 2) / (2 * x)
  angle = math.degree(math.atan(L_t))
  
print(round(angle, 10))

Submission status: Runtime Error

Solution code:
import math

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

area_base = a ** 2
volum_bottle = area_base * b

k = (2 * volum_bottle) / a ** 2

if k <= b:
  K_t = k / a
  angle = math.degree(math.atan(K_t))
else:
  L_t = a * (b ** 2) / (2 * x)
  angle = math.degree(math.atan(L))
  
print(round(angle, 10))

Submission status: Runtime Error

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

#1度傾けると何㎝水が進むか
angle_1 = b / 90

#水の高さ
l_water = b - ((a**2 * b) - x) / a ** 2

#残りの高さ
l_Remaining = b - l_water

#角度
angle = l_Remaining / angle_l

print(angle)

Submission status: Runtime Error

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

Submission status: Runtime Error

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

Submission status: Runtime Error

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

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

Submission status: Runtime Error

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

import math

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

Submission status: Runtime Error

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

import math

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