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

h1 = b - x/a/a
h2 = 2*x/(a*b)


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

Submission status: Runtime Error

Solution code:
#!/usr/bin/env python
# -*- coding: utf-8 -*-
#
# FileName: 	D
# CreatedDate:  2020-07-30 14:02:00 +0900
# LastModified: 2020-07-30 14:39:09 +0900
#


import os
import sys
# import numpy as np
# import pandas as pd
from math import atan, sqrt, degrees


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


if __name__ == "__main__":
    main()

Submission status: Runtime Error

Solution code:
import math
a, b, x = list(map(float, input().split()))
if x <= 0.5 * a * a * b:
    res = math.atan(2 * x / (a * b * b))
else:
    res = math.atan(a / (2 * (b - x / a ** 2)))
print(f'{90 - res * 180 / math.pi:.7f}')

Submission status: Runtime Error

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

if '__main__' == __name__:
    resolve()

Submission status: Runtime Error

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

Submission status: Runtime Error

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

print(math.degrees(math.atan(ans)))

Submission status: Runtime Error

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

Submission status: Runtime Error

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

Submission status: Runtime Error

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

Submission status: Runtime Error

Solution code:
N = int(input())
import math 

start = int(math.sqrt(N))+1
for i in range(start,0,-1):
    if N%i==0:
        print(i+N//i-2)
        break

Submission status: Runtime Error

Solution code:
import math as m


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

if x >= b * a**2 / 2:
    y = 2 * (b - x / (a**2))
    print(90 - m.atan(a / y) * 180 / m.pi)
else:
    y = 2 * x / (a * b)
    print(90 - m.atan(y / b) * 180 / m.pi)

Submission status: Runtime Error

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

Submission status: Runtime Error

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

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

Submission status: Runtime Error

Solution code:
import sys
import itertools
# import numpy as np
import time
import math
 
sys.setrecursionlimit(10 ** 7)
 
from collections import defaultdict
 
read = sys.stdin.buffer.read
readline = sys.stdin.buffer.readline
readlines = sys.stdin.buffer.readlines

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

v = a * a * b
s = x / a


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

Submission status: Runtime Error

Solution code:
import sys
import itertools
# import numpy as np
import time
import math
 
sys.setrecursionlimit(10 ** 7)
 
from collections import defaultdict
 
read = sys.stdin.buffer.read
readline = sys.stdin.buffer.readline
readlines = sys.stdin.buffer.readlines

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

v = a * a * b
s = x / a


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

Submission status: Runtime Error

Solution code:
import sys
import itertools
# import numpy as np
import time
import math
 
sys.setrecursionlimit(10 ** 7)
 
from collections import defaultdict
 
read = sys.stdin.buffer.read
readline = sys.stdin.buffer.readline
readlines = sys.stdin.buffer.readlines

import math

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

v = a * a * b
s = x / a


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

Submission status: Runtime Error

Solution code:
import sys
import itertools
# import numpy as np
import time
import math
 
sys.setrecursionlimit(10 ** 7)
 
from collections import defaultdict
 
read = sys.stdin.buffer.read
readline = sys.stdin.buffer.readline
readlines = sys.stdin.buffer.readlines

import math

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

v = a * a * b
s = x / a


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

Submission status: Runtime Error

Solution code:
import sys
import itertools
# import numpy as np
import time
import math
 
sys.setrecursionlimit(10 ** 7)
 
from collections import defaultdict
 
read = sys.stdin.buffer.read
readline = sys.stdin.buffer.readline
readlines = sys.stdin.buffer.readlines

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

v = a * a * b
s = 0
try:
    s = x / a
except:
    s = 0

import math

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

Submission status: Runtime Error

Solution code:
import sys
import itertools
# import numpy as np
import time
import math
 
sys.setrecursionlimit(10 ** 7)
 
from collections import defaultdict
 
read = sys.stdin.buffer.read
readline = sys.stdin.buffer.readline
readlines = sys.stdin.buffer.readlines

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

v = a * a * b
s = x / a

import math

try:
    if x < v / 2:
        # print(math.degrees(math.atan(2 * s / b / b)))
        print(90 - math.degrees(math.atan(2 * s / b / b)))
    else:
        print(90 - math.degrees(math.atan(a / (b - (2 * s / a - b)))))
except expression as identifier:
    print(90)

Submission status: Runtime Error

Solution code:
import sys
import itertools
# import numpy as np
import time
import math
 
sys.setrecursionlimit(10 ** 7)
 
from collections import defaultdict
 
read = sys.stdin.buffer.read
readline = sys.stdin.buffer.readline
readlines = sys.stdin.buffer.readlines

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

v = a * a * b
s = x / a

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

Submission status: Runtime Error

Solution code:
import sys
import itertools
# import numpy as np
import time
import math
 
sys.setrecursionlimit(10 ** 7)
 
from collections import defaultdict
 
read = sys.stdin.buffer.read
readline = sys.stdin.buffer.readline
readlines = sys.stdin.buffer.readlines

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

v = a * a * b
s = x / a

import math
if x < v / 2:
    # print(math.degrees(math.atan(2 * s / b / b)))
    print(90 - math.atan(2 * s / b / b) * 180 / math.pi)
else:
    print(90 - math.atan(a / (b - (2 * s / a - b))) * 180 / math.pi)

Submission status: Runtime Error

Solution code:
import sys
import itertools
# import numpy as np
import time
import math
 
sys.setrecursionlimit(10 ** 7)
 
from collections import defaultdict
 
read = sys.stdin.buffer.read
readline = sys.stdin.buffer.readline
readlines = sys.stdin.buffer.readlines

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

v = a * a * b
s = x / a

import math
if x <= v / 2:
    # print(math.degrees(math.atan(2 * s / b / b)))
    print(90 - math.atan(2 * s / b / b) * 180 / math.pi)
else:
    print(90 - math.atan(a / (b - (2 * s / a - b))) * 180 / math.pi)

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

Submission status: Runtime Error

Solution code:
import numpy as np

a,b,x = input().split()
a = int(a)
b = int(b)
x = int(x)
ans = 0.000000000
if 2*x/(a**2) < b:
  l = 2*x/(a*b)
  ans = np.arctan(l/b)
else:
  l = 2 * (b - x/(a**2))
  ans = np.arctan(a/l)

ans = 90 - np.rad2deg(ans)
print('{:.10f}'.format(ans))

Submission status: Runtime Error

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

Submission status: Runtime Error

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

Submission status: Runtime Error

Solution code:
import math
from decimal import Decimal
A,B,X = map(Decimal, input().split())
s = X / A

if s > A * B / 2:
    Bu = 2 * s / A - B
    s -= A*Bu
    B -= Bu

A2 = 2 * s / B
print(math.degrees(math.atan(B/(A2))))

Submission status: Runtime Error

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

tan = (a*a*a)/(2*(a*a*b-x))
tan_thre = a/b

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

Submission status: Runtime Error

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

Submission status: Runtime Error

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

Submission status: Runtime Error

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

Submission status: Runtime Error

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

Submission status: Runtime Error

Solution code:
import math

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

if x==a**2*b/2:
    print(45.0)
elif x>a**2*b/2:
    print(90.0-math.degrees(math.atan(a**3/(2*a**2*b-2*x))))
else:
    print(90.0-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.0-math.degrees(math.atan(a**3/(2*a**2*b-2*x))))
else:
    print(90.0-math.degrees(math.atan(2*x/(a*b**2))))

Submission status: Runtime Error

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

if a**2 * b <= 2 * x:
    h = (a**2 * b - x) / a**2 * 2
    theta = h / (a**2 + h**2)**0.5
    ans = math.degrees(math.asin(theta))
else:
    h = 2 * x / a / b
    theta = h / (b**2 + h**2)**0.5
    ans = math.degrees(math.acos(theta))

print(ans)

Submission status: Runtime Error

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

if(x < 0.5*a*a*b):
    y = x/(0.5*b*a)
    ans = 90-degrees(atan(y/b))
    print(ans)
elif(x == 0.5*a*a*b)    
    print(0)
else:
    y = x/(0.5*a**2)-b
    ans = 90-degrees(atan((a/(b-y))))
    print(ans)

Submission status: Runtime Error

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

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

Submission status: Runtime Error

Solution code:
from math import atan, radians, degrees

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

if 2*h >= b:
    ans = degrees(atan((2*b-2*h)/a))
    print(ans)

else 2*he >= a:
    ans = degrees(atan(b**2/(2*h*a)))
    print(ans)

Submission status: Runtime Error

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

Submission status: Runtime Error

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

print(ans)

Submission status: Runtime Error

Solution code:
import math

def solution(a, b, x):
    return math.degrees(math.atan(a** 3 / (a**2 * b - x) / 2))

if __name__ == '__main__':
    a, b, x = map(int, input().split())
    answer = solution(a, b, x)
    print(answer)

Submission status: Runtime Error

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

space=A*A*B-X
h=space/(A*A)*2
import numpy
print(numpy.atan(h/A))

Submission status: Runtime Error

Solution code:
import math

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

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

Submission status: Runtime Error

Solution code:
import math

A,B,X = map(int,input().split())

fullBottle = A*A*B

if fullBottle >= X*2:
    C = 2*X/(A*B)
    ans = math.degrees(math.atan(C/B))
    print(90-ans)
else:
    C = 2*(B-X/(A**2))
    ans = math.degrees(math.atan(A/C))
    print(90-ans)

Submission status: Runtime Error

Solution code:
import math

A,B,X = map(int,input().split())

fullBottle = A*A*B

if fullBottle >= X*2:
    C = 2*X/(A*B)
    ans = math.degrees(math.atan(C/B))
    print(90-ans)
else:
    C = 2*(B-X/(A**2))
    ans = math.degrees(math.atan(A/C))
    print(90-ans)

Submission status: Runtime Error

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

Submission status: Runtime Error

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

Submission status: Runtime Error

Solution code:
import sys, math
input = lambda: sys.stdin.readline().rstrip() 
sys.setrecursionlimit(10**7)
INF = 10**20
def I(): return int(input())
def F(): return float(input())
def S(): return input()
def LI(): return [int(x) for x in input().split()]
def LI_(): return [int(x)-1 for x in input().split()]
def LF(): return [float(x) for x in input().split()]
def LS(): return input().split()

def resolve():
    a, b, x = LI()

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

if __name__ == '__main__':
    resolve()

Submission status: Runtime Error

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

Submission status: Runtime Error

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

Submission status: Runtime Error

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

if x==a*a*b/2:
  ans=a/b
elif x<a*a*b/2:
  t=a-2*x/(a*b)
  ans=(a-t)/b
else:
  t=2*x/(a**2)-b
  ans=a/(b-t)

print(90-math.degrees(math.atan(ans)))

Submission status: Runtime Error

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

Submission status: Runtime Error

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

Submission status: Runtime Error

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

Submission status: Runtime Error

Solution code:
import math

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

Submission status: Runtime Error

Solution code:
from math import pi, tan
EPS = 0.0000000001

def f(a, b, theta):
    if theta >= pi * 0.5:
        return 0.0
    elif tan(theta) >= b / a:
        return a * b**2 * 0.5 / tan(theta)
    else:
        return a**2 * b - a**2 *b * 0.5 * tan(theta)

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

l = 0
r = pi * 0.5
while r - l >= EPS:
    mid = (l + r) * 0.5
    if f(a, b, theta) >= x:
        l = mid
    else:
        r = mid

print("{:.10f}".format(l / pi * 180))

Submission status: Runtime Error

Solution code:
import math

a, b, x = map(int,input().split())
h = x/(a**2) #真っ直ぐ入れた時の高さ
s = b*h #四角形の面積
print(h, s)

if h*2 <= b: #こぼれる時に三角形
    ans = math.degrees(math.atan(b**2/2/s))

elif h*2 < b: #こぼれる時に台形
    print(1)
print(ans)

Submission status: Runtime Error

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

Submission status: Runtime Error

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

Submission status: Runtime Error

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

Submission status: Runtime Error

Solution code:
print(a)

Submission status: Runtime Error

Solution code:
from math import atan, atan2, degrees

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

th = atan2(a, b)

tmp1 = atan(a**3 / (2 * (a**2 * b - x)))
tmp2 = atan(2 * x / (a * b**2))

if tmp1 <= th:
    print(90 - degrees(tmp2))
else:
    print(90 - degrees(tmp1))

Submission status: Runtime Error

Solution code:
from math import *

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

th = atan2(a, b)

tmp1 = atan(a**3 / (2 * (a**2 * b - x)))
tmp2 = atan(2 * x / (a * b**2))

if tmp1 <= th:
    print(90 - degrees(tmp2))
else:
    print(90 - degrees(tmp1))

Submission status: Runtime Error

Solution code:
#!/usr/bin/env python3
import sys
import math

def solve(A: int, B: int, X: int):
    
    S = X / A
    if S >= A * B / 2:
        r = 2 * (B - X / A ** 2)
        t = A / r
    else:
        h = 2 * S / B
        t = h / B
        print(h)
    print(90 - math.degrees(math.atan(t)))
    return


# Generated by 1.1.6 https://github.com/kyuridenamida/atcoder-tools  (tips: You use the default template now. You can remove this line by using your custom template)
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: Runtime Error

Solution code:
#!/usr/bin/env python3
import sys
import math

def solve(A: int, B: int, X: int):
    
    S = X / A
    if S >= A * B / 2:
        r = 2 * (B - S / A)
        t = A / r
    else:
        h = 2 * S / B
        t = h / B
        print(h)
    print(90 - math.degrees(math.atan(t)))
    return


# Generated by 1.1.6 https://github.com/kyuridenamida/atcoder-tools  (tips: You use the default template now. You can remove this line by using your custom template)
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: Runtime Error

Solution code:
import math

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

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

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

Submission status: Runtime Error

Solution code:
import math

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

V = a * a * b
if x * 2 <= V:
    tmp = 2 * x / (a * b * b)
else:
    tmp = a / (2 * (b - x / (a ** 2)))

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

Submission status: Runtime Error

Solution code:
import sys
def input(): return sys.stdin.readline().rstrip()
import math
def main():
    a,b,x=map(int,input().split())
    if x==a**2/b:
        print(90)
        sys.exit()
    if x<=a**2*b/2:
        print(90.0-math.degrees(math.atan((2*x)/(a*b**2))))
    else:
        z=2*x/a**2-b
        print(90.0-math.degrees(math.atan(a/(b-z))))

if __name__=='__main__':
    main()

Submission status: Runtime Error

Solution code:
import sys
def input(): return sys.stdin.readline().rstrip()
import math
def main():
    a,b,x=map(int,input().split())
    if x<=a**2*b/2:
        #x=y*b*a/2
        #y=2*x/(a*b)
        print(90.0-math.degrees(math.atan((2*x)/(a*b**2))))
    else:
        #x-a^**2*b/2=a**2*z/2
        z=2*x/a**2-b
        print(90.0-math.degrees(math.atan(a/(b-z))))

if __name__=='__main__':
    main()

Submission status: Runtime Error

Solution code:
#n=int(input())
a,b,x=map(int,input().split())
#l=list(map(int,input().split()))
#l=[list(map(int,input().split())) for i in range(n)]

import math

s=x/a
if s<= a*b/2:
    c=2*s/b
    deg=math.degrees(math.atan(c/b))
    ans=90.0-deg
    print('{:.9f}'.format(ans))
else:
    s=a*b-s
    h=2*s/a
    deg=math.degrees(math.atan(a/h))
    ans=90.0-deg
    print('{:.9f}'.format(ans))

Submission status: Runtime Error

Solution code:
#n=int(input())
a,b,x=map(int,input().split())
#l=list(map(int,input().split()))
#l=[list(map(int,input().split())) for i in range(n)]

import math

s=x/a
if s<= a*b/s:
    c=2*s/b
    deg=math.degrees(math.atan(c/b))
    ans=90.0-deg
    print('{:.9f}'.format(ans))
else:
    s=a*b-s
    h=2*s/a
    deg=math.degrees(math.atan(a/h))
    ans=90.0-deg
    print('{:.9f}'.format(ans))

Submission status: Runtime Error

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

Submission status: Runtime Error

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

if x>=a*a*b/2:
  tanθ = math.degrees(math.atan(a**2/(2*(a*b-x/a))))
elif 0<x<a*a*b/2:
  tanθ = math.degrees(math.atan(2*x/(a*b*b)))
elif x==0:
  tanθ = 90

print(90-tanθ)

Submission status: Runtime Error

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

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

print(90-tanθ)

Submission status: Runtime Error

Solution code:
n, k = map(int, input().split())
a = list(map(int, input().split()))
f = list(map(int, input().split()))
a.sort()
f.sort(reverse=True)
costs = [(ai * fi, fi) for ai, fi in zip(a, f)]
costs.sort(reverse=True)
# l impossible, r ok
l, r = -1, costs[0][0]
while(r - l > 1):
    c = (l + r) // 2
    train = 0
    for cost, step in costs:
        if cost > c:
            train += (cost - c + step - 1) // step
    if train <= k:
        r = c
    else:
        l = c
print(r)

Submission status: Runtime Error

Solution code:
from math import atan, degrees


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

if a * b / 2 * a < x:
    res = (a ** 3) / (2 * ((a ** 2) * b - x))
else:
    res = 2 * x / (a * b * b)

res = degrees(atan(1 / res))
print(res)

Submission status: Runtime Error

Solution code:
from math import atan, pi


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

if a * b / 2 * a < x:
    res = (a ** 3) / (2 * ((a ** 2) * b - x))
else:
    res = 2 * x / (a * b * b)

res = atan(1 / res) / pi * 180
print(res)

Submission status: Runtime Error

Solution code:
# 過去のジャッジに言語アップデートが適用されればACする
# 2020.04.18

from math import atan, pi


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

if a * b / 2 * a <= x:
    res = (a ** 3) / (2 * ((a ** 2) * b - x))
else:
    res = 2 * x / (a * b * b)

res = atan(1 / res) / pi * 180
print(res)

Submission status: Runtime Error

Solution code:
from math import atan, pi


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

if a * b / 2 * a <= x:
    res = (a ** 3) / (2 * ((a ** 2) * b - x))
else:
    res = 2 * x / (a * b * b)

res = atan(1 / res) / pi * 180
print(res)

Submission status: Runtime Error

Solution code:
from math import atan, pi


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

res = (a ** 3) / (2 * ((a ** 2) * b - x))

res = atan(1 / res) / pi * 180
print(res)

Submission status: Runtime Error

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

Submission status: Runtime Error

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

Submission status: Runtime Error

Solution code:
import math

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

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

Submission status: Runtime Error

Solution code:
import math

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

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

Submission status: Runtime Error

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

Submission status: Runtime Error

Solution code:
from math import degrees, atan

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

vol = a * a * b

def A(a, b, x):
    return degrees(atan((a * b * b) / (2 * x)))

if 2 * x > vol:
    x -= vol / 2
    tmp = A(a, a, vol / 2 - x)
    result = 90 - tmp
else:
    result = A(a, b, x)

print(result)

Submission status: Runtime Error

Solution code:
from math import degrees, atan

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

half_vol = a * a * b / 2

def A(a, b, x):
    return degrees(atan((a * b * b) / (2 * x)))

if x > half_vol:
    x -= half_vol
    tmp = A(a, a, half_vol - x)
    result = 90 - tmp
else:
    result = A(a, b, x)

print(result)

Submission status: Runtime Error

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

Submission status: Runtime Error

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

Submission status: Runtime Error

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

Submission status: Runtime Error

Solution code:
import numpy as np

pi = np.pi

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

S = x/a

if S >= a*b/2:
    h = x/(a**2)
    ans = np.arctan(a / 2 / (b - h)) / (2 * pi) * 360
elif S <= a*b/2:
    ans = np.arctan(b/(2*S/b)) / (2 * pi) * 360

print(ans)

Submission status: Runtime Error

Solution code:
import numpy as np

pi = np.pi

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

S = x/a

if S >= a*b/2:
    ans = np.arctan(a / 2 / (b - h)) / (2 * pi) * 360
elif S <= a*b/2:
    ans = np.arctan(b/(2*S/b)) / (2 * pi) * 360

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

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

Submission status: Runtime Error

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