Problem:
Triangle For given two sides of a triangle a and b and the angle C between them, calculate the following properties:  S : Area of the triangle  L : The length of the circumference of the triangle  h : The height of the triangle with side a as a bottom edge  Input The length of a , the length of b and the angle C are given in integers. Output Print S , L and h in a line respectively. The output should not contain an absolute error greater than 10 -4 . Sample Input 4 3 90 Sample Output 6.00000000
12.00000000
3.00000000

Solution (Python):
import math
a,b,c=map(int,input().split())

s=a*b/2*math.sin(math.radians(c))
l=a+b+math.sqrt(a**2+b**2-2*a*b*math.cos(math.radians(c)))
h=b*math.sin(math.radians(c))

print(s)
print(l)
print(h)

Solution (Python):

import math

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

d=math.radians(c)
s=1/2*a*b*math.sin(d)
h=b*math.sin(d)
e=abs(math.sqrt(b**2+a**2-2*a*b*math.cos(d)))
l=a+b+e
print('{:.8f}'.format(s))
print('{:.8f}'.format(l))
print('{:.8f}'.format(h))

Solution (Python):
import math

a, b, c = map(float, input().split())
h = b * math.sin(math.radians(c))
w = b * math.cos(math.radians(c))
s = a * h / 2
l = a + math.sqrt(h ** 2 + w ** 2) + math.sqrt(h ** 2 + (a - w) ** 2)
print(s)
print(l)
print(h)

Solution (Python):
import math

a,b,C = map(int, input().split())
S = (1/2)*a*b*math.sin(math.radians(C))
L = (a**2+b**2-2*a*b*math.cos(math.radians(C)))**(1/2)+a+b
h = 2*S/a
print(S)
print(L)
print(h)

Solution (Python):
a, b, c = map(int, input().split())

from math import sin
from math import cos
from math import sqrt
from math import radians
c = radians(c)
S = a * b * sin(c) / 2
c_len = sqrt(a**2 + b**2 -2*a*b*cos(c))
L = a + b + c_len
h = 2*S/a

print(S, L, h)

Solution (Python):
import math
a,b,C = map(int,input().split())
C = math.radians(C)
print(a*b*math.sin(C)/2)
print(math.sqrt(a*a+b*b-2*a*b*math.cos(C))+a+b)
print(b*math.sin(C))

Solution (Python):
import math
a, b, c = map(int, input().split())
c = c * math.pi / 180
h = b * math.sin(c)
d = math.sqrt(b ** 2 + a ** 2 - 2 * b * a * math.cos(c))
S = a * h / 2
print(S)
print(a + b + d)
print(h)

Solution (Python):
import math
a, b, c = map(int, input().split())
h = b * math.sin(math.radians(c))
print(a * h / 2)
print(a + b + math.sqrt((a-b*math.cos(math.radians(c)))**2 + h**2))
print(h)

Solution (Python):
import math
a,b,C = map(float,input().split())
h = b*math.sin(math.radians(C))
c = math.sqrt(a**2+b**2-2*a*b*math.cos(math.radians(C)))

r = a+b+c
print(a*h/2)

print(r)
print(h)

Solution (Python):
import math
a,b,c = map(float, input().split())
print(0.5*a*b*math.sin(math.radians(c)))
print(math.sqrt(a*a + b*b -2*a*b*math.cos(math.radians(c)))+a+b)
print(b*math.sin(math.radians(c)))

Solution (Python):
import math
a, b, c = map(int, input().split())

LL = (a * a) + (b * b) - 2 * a * b * math.cos(math.radians(c))
L = math.sqrt(LL) + a + b
h = b * math.sin(math.radians(c))
S = a * b * math.sin(math.radians(c)) / 2

print(S)
print(L)
print(h)

Solution (Python):
import math
a,b,C = map(float,input().split())
C = math.radians(C)

c =(a ** 2 + b ** 2 - 2 * a * b * math.cos(C)) ** 0.5

S = 1/2 * a * b * math.sin(C)
L = a + b + c
h = b * math.sin(C)

print(S)
print(L)
print(h)

Solution (Python):
import math

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

rC = math.radians(C)
a2 = a ** 2
b2 = b ** 2
ab = a * b

c = math.sqrt(a2 + b2 - 2 * ab * math.cos(rC))

S = ab * math.sin(rC) / 2
L = a + b + c
h = b * math.sin(rC)

print(f"{S:.5f} {L:.5f} {h:.5f}")

Solution (Python):
import math
a,b,C=map(float,input().split())
θ=math.radians(C)
h=b*math.sin(θ)
S=(a*h)/2
c=math.sqrt(a**2+b**2-2*a*b*math.cos(θ))
L=a+b+c
print(S,L,h,)

Solution (Python):
import math
a,b,kakudo = map(float,input().split())


c2 = a ** 2 + b ** 2 - 2*a*b*math.cos(math.radians(kakudo))
c = math.sqrt(c2)

S = a*b/2*math.sin(math.radians(kakudo))
L = a+b+c
h = S*2/a

print(S)
print(L)
print(h)

Solution (Python):

import math

a,b,C = map(float,input().split())
C = math.radians(C)
c = math.sqrt(a**2 + b**2 - 2 * a * b * math.cos(C))
L = a + b + c
h = b * math.sin(C)
S = a * h / 2

print(S)
print(L)
print(h)

Solution (Python):
import math
a, b, C = map(float, input().split())
S = a * b * math.sin(math.radians(C)) / 2
c = 0
c = math.sqrt(a**2 + b**2 - 2*a*b*math.cos(math.radians(C)))
L = a + b + c
h = 2 * S / a

print(S)
print(L)
print(h)

Solution (Python):
from math import sqrt, sin, cos, pi

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


C = (C * pi) / 180


c = sqrt(a**2 + b**2 - 2*a*b*cos(C))
height = b * sin(C)
size = a * height * (1/2)
length = a + b + c


print('{:.8f}'.format(size))
print('{:.8f}'.format(length))
print('{:.8f}'.format(height))

Solution (Python):
import math
a, b, C = map(float,input().split())
S = 0.5 * a * b * math.sin(math.pi * C / 180)
L = math.sqrt(a * a + b * b - 2 * a * b * math.cos(math.pi * C / 180)) + a + b
h = 2 * S / a
print(S)
print(L)
print(h)

Solution (Python):
import math

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

rad = C / 180 * math.pi
h = b * math.sin(rad)
L = math.sqrt(a**2 + b**2 - 2 * a * b * math.cos(rad)) + a + b
S = h * a / 2 

print(S)
print(L)
print(h)

Solution (Python):
import math

a,b,c=map(float, input().split(" "))

S=a*b*math.sin(c*math.pi/180.0)/2.0
print(S)
L=a+b+math.sqrt(a*a+b*b-2*a*b*math.cos(c*math.pi/180.0))
print(L)
h=b*math.sin(c*math.pi/180.0)
print(h)

Solution (Python):
import math

a,b,C = map(float,input().split())
S = 0
L = 0
h = 0

S = 0.5 * a * b *math.sin(math.radians(C))
L = (a**2 + b**2 - 2*a*b*math.cos(math.radians(C)))**0.5 + a + b
h = b*math.sin(math.radians(C))
print(S)
print(L)
print(h)

Solution (Python):
import math

a, b, c = [int(x) for x in input().split()]
theta = c/180*math.pi

S = a*b*math.sin(theta)/2
d = math.sqrt(a**2+b**2-2*a*b*math.cos(theta))
L =a+b+d
h = 2*S/a

print(f"{S:.6f}")
print(f"{L:.6f}")
print(f"{h:.6f}")

Solution (Python):
import math
a, b, C = map(float, input().split())
C = math.radians(C)
S = 1 / 2 * math.sin(C) * a * b
L = a + b + math.sqrt(a**2 + b**2 - 2 * a * b * math.cos(C))
h = b * math.sin(C)
print(S)
print(L)
print(h)

Solution (Python):
import math
term = input().split()
a = int(term[0])
b = int(term[1])
c = int(term[2])

sin = math.sin(math.radians(c))
cos = math.cos(math.radians(c))
print('{}'.format(a*b*sin/2))
print('{}'.format(a+b+math.sqrt(a**2 + b**2 - 2*a*b*cos)))
print('{}'.format(b*sin))

Solution (Python):
import math

if __name__ == "__main__":
    a, b, C = list(map(int, input().split()))

    S = a * math.sin(math.radians(C)) * b * 0.5
    L = a + b + math.sqrt(a ** 2 + b ** 2 - (2 * a * b * math.cos(math.radians(C))))
    h = math.sin(math.radians(C)) * b

    print(S)
    print(L)
    print(h)

Solution (Python):
a,b,c = map(float, input().split())

import math
h = math.sin(math.radians(c)) * b
s = a * h / 2

a1 = math.cos(math.radians(c)) * b
a2 = a - a1
x = (a2 ** 2 + h ** 2) ** 0.5
l = a + b + x

print(s)
print(l)
print(h)

Solution (Python):
import math
a, b, C_deg = map(float, input().split())
C_rad = C_deg/360 * 2 * math.pi
S = a * b * math.sin(C_rad) /2
c = math.sqrt((a*math.sin(C_rad))**2 + (b - a*math.cos(C_rad))**2)
L = a + b + c
h = S*2/a
print(str(S))
print(str(L))
print(str(h))

Solution (Python):
import math

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

r = math.radians(C)
S = a * b * math.sin(r) / 2
c = ((a ** 2) + (b ** 2) - (2 * a * b * math.cos(r))) ** 0.5
L = a + b + c
h = 2 * S / a

print(S, L, h)

Solution (Python):
import math
a,b,C=map(float,input().split())

s=math.radians(C)
h=b*math.sin(s)
S=(a*h)/2
c=math.sqrt(a**2+b**2-2*a*b*math.cos(s))
L=a+b+c
print(S,L,h,sep="\n")

Solution (Python):
import math
a, b, c = map(float, input().split())
c = c*math.pi/180
S = 0.5*a*b*math.sin(c)
d = (a**2 + b**2 - 2*b*a*math.cos(c))**0.5
L = a + b + d
h = b*math.sin(c)
print (S, L, h, end="\n")

Solution (Python):
import math
a, b, C = (float(x) for x in input().split())
S = a * b * math.sin(math.radians(C)) / 2.0
L = math.sqrt(a**2 + b**2 - 2*a*b*math.cos(math.radians(C))) + a + b
h = b * math.sin(math.radians(C))
print(S)
print(L)
print(h)

Solution (Python):
import math

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

S = 0.50 * a * b * math.sin(math.radians(c_deg))
c = math.sqrt(a**2 + b**2 - 2*a*b*math.cos(math.radians(c_deg)))
L = a + b + c
h = b * math.sin(math.radians(c_deg))

print(f"{S:.5f} {L:.5f} {h:.5f}")

Solution (Python):
import math
a,b,c = map(int, input().split())
sin_c = math.sin(math.radians(c))
S = a*b*sin_c/2

cos_c = math.cos(math.radians(c))
L = a + b + (a**2+b**2-2*a*b*cos_c)**0.5

h = b*sin_c

print(S,L,h)

Solution (Python):
import math

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

c = math.radians(c)

sinc = math.sin(c)
cosc = math.cos(c)

S = (a*b*sinc)/2
L = a + b + math.sqrt(a**2+b**2 -2*a*b*cosc)
h = b*sinc

print(S,L,h,sep="\n")

Solution (Python):
import math
a,b,c= map(float,input().split())
def triangle(A,B,C):
    S = math.sin(math.radians(C))*A*B/2
    L = A+B+math.sqrt(A**2+b**2-2*A*B*math.cos(math.radians(C)))
    H=2*S/A
    print(S)
    print(L)
    print(H)

triangle(a,b,c)

Solution (Python):
import math

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

S = (a * b * math.sin(math.radians(C))) / 2
L = a + b + math.sqrt(a**2 + b**2 - 2*a*b*math.cos(math.radians(C)))
h = (2*S)/a

print(S)
print(L)
print(h)

Solution (Python):
import math
a,b,c = map(float,input().split())
s = 0.5*a*b*math.sin(math.radians(c))
l = a+b+math.sqrt(a*a+b*b-2*a*b*math.cos(math.radians(c)))
h = 2*s/a
print(s,l,h, sep='\n')

Solution (Python):
import math

a, b, c = list(map(float, input().split()))

h = b * math.sin(math.radians(c))

S = (1/2) * a * h

x = b * math.cos(math.radians(c))

side = ((a-x)**2 + h**2) ** (1/2)

L = a + b + side

print(S)
print(L)
print(h)

Solution (Python):
import math

a, b, c = map(int, input().split())
sin_c = math.sin(math.radians(c))
cos_c = math.cos(math.radians(c))

s = (a*b*sin_c) / 2
l = math.sqrt(a**2+b**2-2*a*b*cos_c) + a + b
h = b*sin_c

print(s)
print(l)
print(h)

Solution (Python):
import math

a, b, C = map(float, input().split())
C = C / 180 * math.pi  

h = b * math.sin(C)
S = a * h / 2
c = math.sqrt((a - b * math.cos(C)) ** 2 + h ** 2)
L = a + b + c

print(S)
print(L)
print(h)

Solution (Python):
import sys
import math
a,b,c=map(int,input().split())
h=float(b)*math.sin(float(c)*math.pi/180.0)
S=float(a)*float(h)/2;
L=float(a)+float(b)+math.sqrt((float(a)*float(a))+(float(b)*float(b))-(2*float(a)*float(b)*math.cos(float(c)*math.pi/180)));
print(str('{:.08f}'.format(S)))
print(str('{:.08f}'.format(L)))
print(str('{:.08f}'.format(h)))

Solution (Python):
import math
a,b,c=map(float, input().split())
c=int(c)
c=math.pi*c/180
S=a*b*math.sin(c)/2
L=a+b+(a**2+b**2-2*a*b*math.cos(c))**(1/2)
h=b*math.sin(c)
print(round(S,6))
print(round(L,6))
print(round(h,6))

Solution (Python):
import math

class Triangle:
    def __init__(self, a, b, c):
        self.s1 = a
        self.s2 = b
        self.rad = math.radians(c)

    def s3(self):
        return math.sqrt(self.s1**2 + self.s2**2 \
                             - 2*self.s1*self.s2*math.cos(self.rad))

    def area(self):
        return 0.5 * self.s1 * self.s2 * math.sin(self.rad)

    def height(self):
        return b * math.sin(self.rad)

    def length(self):
        return self.s1 + self.s2 + self.s3()


a, b, c = map(float, input().split())
triangle = Triangle(a, b, c)

print(triangle.area())
print(triangle.length())
print(triangle.height())

Solution (Python):
from enum import Enum
import sys
import math


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

rad = math.radians(DEGREE)

S = A*B*math.sin(rad)/2.0
C = math.sqrt(A*A+B*B-2*A*B*math.cos(rad))
h = 2*S/A

print("%.10f %.10f %.10f"%(S,A+B+C,h))

Solution (Python):
import math
a,b,C=map(float,input().split())
θ=math.radians(C)
h=b*math.sin(θ)
S=(a*h)/2
c=math.sqrt(a**2+b**2-2*a*b*math.cos(θ))
L=a+b+c
print(S,L,h,sep="\n")

Solution (Python):
from math import sin, cos, pi


a, b, theta = map(float, input().split())
theta *= pi / 180
s = 0.5 * a * b * sin(theta) 

print(s) 
print((a ** 2 + b ** 2 - 2 * a * b * cos(theta)) ** 0.5 + a + b)
print(2 * s / a)

Solution (Python):
import math


def get_distance(x1, y1, x2, y2) -> float:
    return math.sqrt(pow(x2 - x1, 2) + pow(y2 - y1, 2))


def get_area(a, b, c) -> float:
    return a * b * math.sin(c * math.pi / 180) / 2


def get_length(a, b, c) -> float:
    return a + b + math.sqrt(pow(a, 2) + pow(b, 2) - 2 * a * b * math.cos(c * math.pi / 180))


def get_height(b, c) -> float:
    return b * math.sin(c * math.pi / 180)


a, b, c = map(float, input().split(' '))
print(get_area(a, b, c))
print(get_length(a, b, c))
print(get_height(b, c))

Solution (Python):

from math import sin,cos,sqrt,radians

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

C = radians(C)

S = 1/2*(a*b*sin(C))

a2,b2 = a**2,b**2
sqrt_p = a2+b2-2*a*b*cos(C)
sqrt_p = sqrt(sqrt_p)
L = a+b+sqrt_p

h = b*sin(C)
print('{:.7f}'.format(S))
print('{:.7f}'.format(L))
print('{:.7f}'.format(h))

Solution (Python):
import math
a,b,c = map(int,input().split())

s = a*b*math.sin(math.radians(c))*0.5

line = a**2 + b**2 - 2*a*b*math.cos(math.radians(c))
l = a + b + math.sqrt(line)

h = (2*s)/a

print(s)
print(l)
print(h)

Solution (Python):
from math import *
a, b, c = map(int, input().split())
theta = radians(c)
S = 0.5*a*b*sin(theta)
H = 2*S/a
L = sqrt(a*a + b*b - 2*a*b*cos(theta)) + a + b
print('%f %f %f' % (S, L, H))

Solution (Python):
import math
import sys
input = sys.stdin.readline().rstrip

a, b, C = map(float, input().split())
C = math.radians(C)

S = a * b * math.sin(C) / 2
L = a + b + math.sqrt(a**2 + b**2 - 2*a*b*math.cos(C))
h = b * math.sin(C)

print(S)
print(L)
print(h)

Solution (Python):
import math
a, b, C = map(float, input().split())
pi = math.pi
rad = C*pi/180
c= math.sqrt(a**2+b**2-2*a*b*math.cos(rad))
S = a*b*math.sin(rad)/2
L=2*S/a
print(S, a+b+c, L)

Solution (Python):
a,b,c = map(int, input().split())

import math



s = 0.5*a*b*math.sin(math.radians(c))

ab = math.sqrt(a**2+b**2-2*a*b*math.cos(math.radians(c)))

h = 2*s/a

print("{:.12f}".format(s))
print("{:.12f}".format(ab+a+b))
print("{:.12f}".format(h))

Solution (Python):


import math


a, b, C = map(int, input().split())
C_radians = math.radians(C)


area_S = a * b * math.sin(C_radians) / 2
c = math.sqrt(a*a + b*b - 2*a*b*math.cos(C_radians))
length_L = a + b + c
height_h = 2 * area_S / a


print(area_S)
print(length_L)
print(height_h)

Solution (Python):
import math
a,b,c = map(float, input().split())
print(0.5*a*b*math.sin(c/180*math.pi))
print(a+b+math.sqrt(a**2 + b**2 - 2*a*b*math.cos(c/180*math.pi)))
print(b*math.sin(c/180*math.pi))

Solution (Python):
from math import sin,cos,sqrt,radians

a,b,C=map(int,input().split())
print("{:.5f}".format(a*b*sin(radians(C))/2))
c2=a**2+b**2-a*b*2*cos(radians(C))
print("{:.5f}".format(a+b+sqrt(c2)))
print("{:.5f}".format(b*sin(radians(C))))

Solution (Python):
import math
a, b, C = map(float, input().split())
C = 2*math.pi/360*C

S = 0.5 * a * b * math.sin(C)
L = a + b + math.sqrt(a**2 + b**2 - 2*a*b*math.cos(C))
h = b * math.sin(C)
print(S, L, h)

Solution (Python):
from math import sin, cos, radians

a, b, c = [int(i) for i in input().split()]
area = 0.5 * a * b * sin(radians(c))
print(area)
print(a + b + (a**2 + b**2 - 2*a*b*cos(radians(c)))**0.5)
print(2 * area / a)

Solution (Python):
import math

def main():
    a,b,d = map(float,input().split())
    d = d*math.pi/180.0
    S = a*b*math.sin(d)/2.0
    c = (a*a+b*b-2.0*a*b*math.cos(d))**(0.5)
    h = S/a*2.0
    print (S,a+b+c,h)



if __name__ == '__main__':
    main()

Solution (Python):
import math
a,b,c = map(int,input().split())
S = 0.5*a*b*math.sin(math.radians(c))
print(S)
print(a+b+math.sqrt(a**2+b**2-2*a*b*math.cos(math.radians(c))))
print(2*S/a)

Solution (Python):
import math 

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

if C == 90 or C == 270:
    h = b
    S = a * h * 0.5
    L = a + b + math.sqrt(a ** 2 + b ** 2)
    
else:
    C = math.radians(C)
    h = b * math.sin(C)
    S = a * h * 0.5
    L = a + b + math.sqrt(a ** 2 + b ** 2 - 2 * a * b * math.cos(C))

print(f"{S:.4f}\n{L:.4f}\n{h:.4f}")

Solution (Python):
import math
s = input().rstrip().split(' ')
a = float(s[0])
b = float(s[1])
c = float(s[2])
surface = a * b * math.sin(math.radians(c)) / 2
d = math.sqrt((a ** 2) + (b ** 2) - (2 * a * b * math.cos(math.radians(c))))
line = a + b + d
h = surface * 2 / a
print(surface)
print(line)
print(h)

Solution (Python):
import math

a, b, c = map(int, input().split())
print('{:f}'.format(a * b * math.sin(math.radians(c)) / 2))
print('{:f}'.format(a + b + math.sqrt(a**2 + b**2 - 2*a*b*math.cos(math.radians(c)))))
print('{:f}'.format(b * math.sin(math.radians(c))))

Solution (Python):
import math
a,b,c=map(float,input().split())
c*=math.pi/180
print(.5*a*b*math.sin(c))
print(a+b+math.sqrt(a*a+b*b-2*a*b*math.cos(c)))
print(b*math.sin(c))

Solution (Python):
import math

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

S = a * b * math.sin(math.radians(C)) / 2
c = (a ** 2 + b ** 2 - 2 * a * b * math.cos(math.radians(C))) ** 0.5
L = a + b + c
h = b * math.sin(math.radians(C))

print(S)
print(L)
print(h)

Solution (Python):
import math

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

s = a * b * 0.5 * math.sin(math.radians(c))
l = a + b + (a**2 + b**2 - 2 * a * b * math.cos(math.radians(c))) ** 0.5
h = b * math.sin(math.radians(c))

print(s)
print(l)
print(h)

Solution (Python):
import math
import copy
from copy import deepcopy
import sys
import fractions

from functools import reduce

import decimal
import heapq
import collections
import itertools
from operator import mul

sys.setrecursionlimit(100001)







def getInputInt():
    inputNum = int(input())
    return inputNum


def getInputListInt():
    outputData = []
    inputData = input().split()
    outputData = [int(n) for n in inputData]

    return outputData


def getSomeInputInt(n):
    outputDataList = []
    for i in range(n):
        inputData = int(input())
        outputDataList.append(inputData)

    return outputDataList


def getSomeInputListInt(n):
    inputDataList = []
    outputDataList = []
    for i in range(n):
        inputData = input().split()
        inputDataList = [int(n) for n in inputData]
        outputDataList.append(inputDataList)

    return outputDataList




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

deg = deg/180*math.pi

s = a*b*math.sin(deg)/2
l = a+b+math.sqrt(a*a+b*b-2*a*b*math.cos(deg))
h = b*math.sin(deg)

print(s)
print(l)
print(h)

Solution (Python):
import math

a, b, C = (int(i) for i in input().split())


Crad = C * math.pi / 180


S = 0.5 * a * b * math.sin(Crad)
print(S)


c = math.sqrt(a**2 + b**2 - 2*a*b*math.cos(Crad))


l = a + b + c
print(l)


h = 2 * S / a
print(h)

Solution (Python):
import math
[a,b,kakudo]=[int(item) for item in input().split()]

h=b*math.sin(math.radians(kakudo))
c=(a*a+b*b - 2*a*b*math.cos(math.radians(kakudo)))**(0.5)
S=a*h/2
print("{} {} {}".format(S,a+b+c,h))

Solution (Python):
import math

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

S = a * b * math.sin(c/180*math.pi) / 2
L = a + b + math.sqrt(a**2 + b**2 - 2 * a * b * math.cos(c/180*math.pi))
h = b * math.sin(c/180*math.pi)

print(S)
print(L)
print(h)

Solution (Python):
from math import sin,cos,pi
a,b,C = map(int, input().split())
Cr = C*pi/180
print(0.5*a*b*sin(Cr))
print(a+b+(a**2+b**2-2*a*b*cos(Cr))**0.5)
print(b*sin(Cr))

Solution (Python):
import math

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

S = 0.5 * a * b * math.sin(math.radians(C))
l = (a**2 + b**2 - 2*a*b*math.cos(math.radians(C)))**0.5 + a + b
h = (2 * S) / a

print(S)
print(l)
print(h)

Solution (Python):
import sys, math
input = sys.stdin.readline

def main():
    a, b, theta = map(int, input().split())
    theta = theta * math.pi / 180
    c = pow(a*a+b*b-2*a*b*math.cos(theta), 0.5)
    h = b * math.sin(theta)
    print(a*h*0.5)
    print(a+b+c)
    print(h)



if __name__ == "__main__":
    main()

Solution (Python):
import math
a,b,c = map(int,input().split())
K = (a*b)*math.sin(math.radians(c))/2
L = math.sqrt((a**2)+(b**2)-2*(a*b)*math.cos(math.radians(c)))
S = a+b+L
print(K)
print(S)
P = 2*K/a
print(P)

Solution (Python):
import math

a,b,C = map(int, input().split())
S = (1/2)*a*b*math.sin(math.radians(C))
L = (a**2+b**2-2*a*b*math.cos(math.radians(C)))**(1/2)+a+b
h = 2*S/a
print(S)
print(L)
print(h)

Solution (Python):
import math
a,b,C=list(map(int,input().split()))
s=(a*b)*math.sin(math.radians(C))/2
L=a+b+math.sqrt(a*a+b*b-2*a*b*math.cos(math.radians(C)))
H=b*math.sin(math.radians(C))
print(s)
print(L)
print(H)

Solution (Python):

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

c = math.sqrt(a**2 + b**2 - 2*a*b*math.cos(math.radians(deg)))

s = (a+b+c)/2

area = (s * (s - a) * (s - b) * (s - c))**0.5

h = area * 2 / a

print(area)
print(a+b+c)
print(h)

Solution (Python):
import math
a,b,C = map(float,input().split())
S = 0.5 * a * b * math.sin(math.radians(C))
c = math.sqrt(a**2+b**2-2*a*b*math.cos(math.radians(C)))
L = a+ b+c
x = (a**2+b**2-c**2)/(2*a)
h = math.sqrt(b**2-x**2)
print(round(S,8))
print(round(L,8))
print(round(h,8))

Solution (Python):
import math

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

rad = math.radians(DEGREE)

S = A*B*math.sin(rad)/2.0
C = math.sqrt(A**2+B**2-2*A*B*math.cos(rad))
h = 2*S/A

print("%.10f %.10f %.10f"%(S,A+B+C,h))

Solution (Python):
from math import sin,cos,radians

a,b,C=map(int,input().split())
radian = radians(C)
S = 0.5 * a* b * sin(radian)

L2 = a**2 + b**2 - 2*a*b*cos(radian)
L = L2**0.5
around = a + b + L

h = b*sin(radian)

print(S, around, h, sep="\n")

Solution (Python):
import math

a, b, angle = map(int,input().split())
sin_C = math.sin(math.radians(angle))
cos_C = math.cos(math.radians(angle))
c = math.sqrt((a**2 + b**2) - 2 * a * b * cos_C)
S = (a * b * sin_C) / 2
L = a + b + c
H = S *2 / a 
print("{} {} {}".format(S, L, float(H)))

Solution (Python):
import math

a,b,C = list(map(float, input().split()))

h = b * math.sin(math.radians(C))
L = math.sqrt(a ** 2 + b ** 2 - 2 * a * b * math.cos(math.radians(C))) + a + b
S = a * h / 2

print("{:f}".format(S))
print("{:f}".format(L))
print("{:f}".format(h))

Solution (Python):
import math
a,b,c=map(int,input().split())
s=(a*b*math.sin(math.radians(c)))/2
l=math.sqrt(a**2+b**2-2*a*b*math.cos(math.radians(c)))
l=l+a+b
h=2*s/a
print(s,l,h)

Solution (Python):
import math
a,b,c = map(float,input().split())
h = math.sin(math.radians(c))
cosA = math.cos(math.radians(c))
S = 0.5*a*b*h
yogen = (a**2 + b**2 - 2*a*b*cosA)**0.5
print(S)
print(a+b+yogen)
print(b*h)

Solution (Python):
import math
a,b,C = map(float,input().split())
C_rad=math.pi*C/180
print("{0:.8f}".format(math.sin(C_rad)*a*b/2))
print("{0:.8f}".format(a+b+math.sqrt(a**2+b**2-2*a*b*math.cos(C_rad))))
print("{0:.8f}".format(b*math.sin(C_rad)))

Solution (Python):
import math
a, b, C = list(map(float, input().split()))
sinC = math.sin(math.radians(C))
S = a * b * sinC /2 
h = (S * 2) / a
c2 = a**2 + b**2 - 2*a*b*math.cos(math.radians(C))
c = math.sqrt(c2)
L = a + b + c
print(S)
print(L)
print(h)

Solution (Python):
import math

a, b, C = map(int, input().split())
s = a * b * math.sin(math.radians(C)) / 2
print(s)
c2 = a ** 2 + b ** 2 - 2 * a * b * math.cos(math.radians(C))
c = c2 ** 0.5
print(a + b + c)
h = s * 2 / a
print(h)

Solution (Python):
import math
a, b, C = map(float, input().split())
S = 0.5 * a * b * math.sin(C * math.pi / 180.0)
c = math.sqrt(a**2 + b**2 - 2 * a * b * math.cos(C * math.pi / 180.0))
h = b * math.sin(C * math.pi / 180.0)
print("{:.10f}".format(S))
print("{:.10f}".format(a + b + c))
print("{:.10f}".format(h))

Solution (Python):
import math
a,b,angle = map(int,input().split())

rad = (angle / 180) * math.pi

c = (a**2 + b**2 - 2 * a * b * math.cos(rad)) ** 0.5
s = (a+b+c)/2
S = (s*(s-a)*(s-b)*(s-c))**0.5
print(format(S,".5f"))
print(format(a+b+c,".5f"))
print(format((2*S)/a,".5f"))

Solution (Python):
import math

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

C = C * math.pi /180

S = a * b * math.sin(C) / 2
L = a + b + math.sqrt(a ** 2 + b ** 2
                             - 2 * a * b *math.cos(C))
h = 2 * S / a

print(S)
print(L)
print(h)

Solution (Python):
import math
a, b, C = map(float, input().split())
C = math.radians(C)
print(1/2 * a * b * math.sin(C))
c = (a ** 2 + b ** 2 - 2 * a * b * math.cos(C)) ** 0.5
print(a + b + c)
print(b * math.sin(C))

Solution (Python):
import math

a, b, angle = map(int, input().split())
angle = math.radians(angle)

S = (a * b * math.sin(angle)) / 2
L = a + b + math.sqrt(a ** 2 + b ** 2 - 2 * a * b * math.cos(angle))
h = b * math.sin(angle)

print("%f %f %f" % (S, L, h))

Solution (Python):
import math

sc = list(map(float, input().split()))
a = sc[0]
b = sc[1]
c = math.pi * sc[2] / 180

s = a * b * math.sin(c) / 2

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

print('{:.10f}'.format(a + b + math.sqrt(a ** 2 + b ** 2 - 2 * a * b * math.cos(c))))

print('{:.10f}'.format(2 * s / a))

Solution (Python):
import math
a,b,C = map(int,input().split())
C = math.radians(C)
S = 0.5*a*b*math.sin(C)
L = a+b+math.sqrt(a**2+b**2-2*a*b*math.cos(C))
h = 2*S/a
print(S,L,h)

Solution (Python):
import sys
import itertools
import math



read = sys.stdin.buffer.read
readline = sys.stdin.buffer.readline
readlines = sys.stdin.buffer.readlines

a, b, C = map(int, readline().split())
sinC = math.sin(math.radians(C))
cosC = math.cos(math.radians(C))

print(a * b * sinC / 2, a + b + (a ** 2 + b ** 2 - 2 * a * b * cosC) ** .5, b * sinC,sep='\n')

Solution (Python):
import math
a, b, c = map(lambda x: float(x), input().split(" "))
h = math.sin(math.radians(c)) * b
S = a * h / 2.0
L = a + b + math.sqrt(a ** 2 + b ** 2 - 2 * a * b * math.cos(math.radians(c)))
print(S)
print(L)
print(h)

Solution (Python):
from math import sin, cos, radians, sqrt

a, b, C = list(map(float, input().split()))

height = b * sin(radians(C))
area = a * height * 0.5
rem_a = a - b * cos(radians(C))
c = sqrt(rem_a ** 2 + height ** 2)
L = a + b + c

print("{:.10f}".format(area))
print("{:.10f}".format(L))
print("{:.10f}".format(height))

Solution (Python):
import math
a,b,theta = map(int,input().split())
theta = math.pi*theta/180
print("{0:.8f}".format(math.sin(theta)*b*a/2))
print("{0:.8f}".format(a+b+math.sqrt(a**2+b**2-2*a*b*math.cos(theta))))
print("{0:.8f}".format(math.sin(theta)*b))

Solution (Python):
import math
a, b, C = map(int, input().split())
C_radian = math.radians(C)

S = a * b * math.sin(C_radian) / 2

l = a ** 2 + b ** 2 - 2 * a * b * math.cos(C_radian)
l = math.sqrt(l) + a + b

h = b * math.sin(C_radian)

print(S)
print(l)
print(h)

Solution (Python):
import math

a, b, c = map(int, input().split())
S = 0.0
L = 0
h = 0.0
if c <= 90:
    h = b * math.sin(math.radians(c))
else:
    h = b * math.sin(math.radians(180 - c))
S = a * h * 0.5
L = (a**2.0 + b**2.0 - 2*a*b*math.cos(math.radians(c)) )**0.5
L = L + a + b
print(S)
print(L)
print(h)

Solution (Python):
import math

a, b, C = map(float, input().split())
S =  0.5 * a * b * math.sin(C * math.pi / 180)
L = a + b + (a ** 2 + b ** 2 - 2 * a * b * math.cos(C * math.pi / 180)) ** 0.5
h = 2 * S / a

print("%f\n%f\n%f" % (S, L, h))

Solution (Python):
import math

a, b, C = map(int, input().split())
S = (a*b*math.sin(math.radians(C))) / 2
L = a + b + math.sqrt(a**2 + b**2 - 2*a*b*math.cos(math.radians(C)))
h = b * math.sin(math.radians(C))
print("%f" %S)
print("%f" %L)
print("%f" %h)

Solution (Python):
import math

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

print(a*b*math.sin(c*math.pi/180)/2)
print(math.sqrt(a*a+b*b-2*a*b*math.cos(c*math.pi/180))+a+b)
print(a*b*math.sin(c*math.pi/180)/a)

Solution (Python):
import math
a,b,c=map(float,raw_input().split())
crad=math.radians(c)
h=b*math.sin(crad)
s=a*h/2
d=(abs((a**2)+(b**2)-(2*a*b*math.cos(crad))))**(0.5)
l=a+b+d
print s
print l
print h

Solution (Python):

import math

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

c = math.radians(C)


S = a * b * math.sin(c) / 2
print(S)


l = (a ** 2 + b ** 2 - 2 * a * b * math.cos(c)) ** (1 / 2)
print(a + b + l)


print(S / a * 2)

Solution (Python):
import math

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

rad = math.radians(DEGREE)

S = A*B*math.sin(rad)/2.0
C = math.sqrt(A*A+B*B-2*A*B*math.cos(rad))
h = 2*S/A

print("%.10f %.10f %.10f"%(S,A+B+C,h))

Solution (Python):
import math
a, b, c = map(int, input().split())

h = b*math.sin(math.radians(c))
s = h*a/2
l = a+b+(a**2+b**2-2*a*b*math.cos(math.radians(c)))**0.5
print("{:.8f}".format(s))
print("{:.8f}".format(l))
print("{:.8f}".format(h))

Solution (Python):
import math

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

s=a*b*(1/2)*math.sin(c*math.pi/180)
x=a**2+b**2-2*a*b*math.cos(c*math.pi/180)
x=math.sqrt(x)
L=a+b+x
h=b*math.sin(c*math.pi/180)

print(s,L,h)

Solution (Python):
import math

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

h = b*math.sin(c/180*math.pi)
s = a*h/2

e = math.sqrt(a**2 + b**2 - 2*a*b*math.cos(c/180*math.pi))

print('%.5f'%s)
print('%.5f'%(a+b+e))
print('%.5f'%h)

Solution (Python):
import math

def S(a,b,C):
    s=(a*b*math.sin(math.radians(C)))/2
    return s

def L(a,b,C):
    l=a+b+(a**2+b**2-2*a*b*math.cos(math.radians(C)))**0.5
    return l

def H(a,b,C):
    h=b*math.sin(math.radians(C))
    return h

a,b,C=map(float,input().split())
print(S(a,b,C))
print(L(a,b,C))
print(H(a,b,C))

Solution (Python):
import math

a, b, c = list(map(float, input().split()))
c = math.radians(c)
s = 0.5 * a * b * math.sin(c)
l = (a + b) + math.sqrt((a ** 2) + (b ** 2) - (2 * a * b * math.cos(c)))
h = b * math.sin(c)

print("{}\n{}\n{}".format(s, l, h))

Solution (Python):
import math
a,b,C = list(map(float, input().split() ))
C = math.radians(C)
h = b*math.sin(C)
S = a*h/2
c = math.sqrt( a**2 + b**2 - 2*a*b*math.cos(C) )
L = a+b+c
print(S)
print(L)
print(h)

Solution (Python):
import math

a,b,C = map(int, input().split())
S = (1/2)*a*b*math.sin(math.radians(C))
L = (a**2+b**2-2*a*b*math.cos(math.radians(C)))**(1/2)+a+b
h = 2*S/a
print(S)
print(L)
print(h)

Solution (Python):
import math

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

if C == 90:
    L = a + b + math.sqrt(a**2 + b**2)
    h = b
    S = (a*b) / 2
else:
    L = a + b + math.sqrt(a**2 + b**2 -2 * a * b * math.cos(math.radians(C)))

    h = b * math.sin(math.radians(C))

    S = 0.5 * a * b * math.sin(math.radians(C))

print(S,L,h)

Solution (Python):

import math
input_data = list(input().split())
a = float(input_data[0])
b = float(input_data[1])
c = int(input_data[2])


sin = math.sin(math.radians(c))
cos = math.cos(math.radians(c))


h = b * sin
s = (a * h)/2 
l = math.sqrt(a**2+b**2-2*a*b*cos)


print(f"{s:.8f}")
print(f"{a+b+l:.8f}")
print(f"{h:.8f}")

Solution (Python):
import math

a,b,c = map(int,input().split())
S = a*b*math.sin(math.radians(c))/2
L = a + b + math.sqrt(a**2+b**2-2*a*b*math.cos(math.radians(c)))
h = b*math.sin(math.radians(c))
print(S)
print(L)
print(h)

Solution (Python):
import math as m

a, b, c = map(float, input().split())
cos_c =  m.cos(m.radians(c))
d = m.sqrt(a ** 2 + b ** 2 - (2 * a * b) * cos_c)

s = (1 / 2) * a * b * m.sin(m.radians(c))
l = a + b + d
h = (2 * s) / a

print(s, l, h, sep="\n")

Solution (Python):
import math
a, b, C = map(int, input().split())
S = a*b*math.sin(C*math.pi/180)/2
L = a+b+(a**2+b**2-2*a*b*math.cos(C*math.pi/180))**0.5
h = 2*S/a
print(S)
print(L)
print(h)

Solution (Python):
import math

a,b,C = list(map(float,input().split()))
C = math.radians(C)  
h = math.sin(C) * b  
remain = math.sqrt(a ** 2 + b ** 2 - (2 * a * b * math.cos(C)))
S = (a * h)/ 2  
print(S)
print(a+b+remain)
print(h)

Solution (Python):
import math as math
a,b,angle = map(float,input().split())
h = b * math.sin(angle*math.pi/180)
s = a * h / 2
if a < b:
    kata = -a + b * math.cos(angle*math.pi/180)
else:
    kata = a - b * math.cos(angle*math.pi/180)
phi=math.atan(h/kata)
nokori = kata/math.cos(phi)
L = a+b+nokori
print(s)
print(L)
print(h)

Solution (Python):
import math

a, b, C = map(int, input().split())
S = a * b * math.sin(math.radians(C)) / 2
L = a + b + math.sqrt(a**2 + b**2 - 2*a*b*math.cos(math.radians(C)))
h = 2 * S / a
print(S)
print(L)
print(h)