from __future__ import annotations

from math import pi, pow

def   a_					(_lowerCAmelCase  :   int | float       )->				float:
    if side_length < 0:
        raise ValueError("""vol_cube() only accepts non-negative values"""       )
    return pow(_lowerCAmelCase			,	3       )

def   a_					(_lowerCAmelCase  :   float			,	_lowerCAmelCase  :   float       )->				float:
    if height < 0 or radius < 0:
        raise ValueError("""vol_spherical_cap() only accepts non-negative values"""       )
    # Volume is 1/3 pi * height squared * (3 * radius - height)
    return 1 / 3 * pi * pow(_lowerCAmelCase			,	2       ) * (3 * radius - height)

def   a_					(_lowerCAmelCase  :   float			,	_lowerCAmelCase  :   float			,	_lowerCAmelCase  :   float       )->				float:
    if radius_a < 0 or radius_a < 0 or centers_distance < 0:
        raise ValueError("""vol_spheres_intersect() only accepts non-negative values"""       )
    if centers_distance == 0:
        return vol_sphere(min(_lowerCAmelCase			,	_lowerCAmelCase       )       )

    snake_case:						int         =   (
        (radius_a - radius_a + centers_distance)
        * (radius_a + radius_a - centers_distance)
        / (2 * centers_distance)
    )
    snake_case:						List[str]         =   (
        (radius_a - radius_a + centers_distance)
        * (radius_a + radius_a - centers_distance)
        / (2 * centers_distance)
    )

    return vol_spherical_cap(_lowerCAmelCase			,	_lowerCAmelCase       ) + vol_spherical_cap(_lowerCAmelCase			,	_lowerCAmelCase       )

def   a_					(_lowerCAmelCase  :   float			,	_lowerCAmelCase  :   float			,	_lowerCAmelCase  :   float       )->				float:

    if radius_a <= 0 or radius_a <= 0 or centers_distance < 0:
        raise ValueError(
            """vol_spheres_union() only accepts non-negative values, non-zero radius"""       )

    if centers_distance == 0:
        return vol_sphere(max(_lowerCAmelCase			,	_lowerCAmelCase       )       )

    return (
        vol_sphere(_lowerCAmelCase       )
        + vol_sphere(_lowerCAmelCase       )
        - vol_spheres_intersect(_lowerCAmelCase			,	_lowerCAmelCase			,	_lowerCAmelCase       )
    )

def   a_					(_lowerCAmelCase  :   float			,	_lowerCAmelCase  :   float			,	_lowerCAmelCase  :   float       )->				float:
    if width < 0 or height < 0 or length < 0:
        raise ValueError("""vol_cuboid() only accepts non-negative values"""       )
    return float(width * height * length       )

def   a_					(_lowerCAmelCase  :   float			,	_lowerCAmelCase  :   float       )->				float:
    if height < 0 or area_of_base < 0:
        raise ValueError("""vol_cone() only accepts non-negative values"""       )
    return area_of_base * height / 3.0

def   a_					(_lowerCAmelCase  :   float			,	_lowerCAmelCase  :   float       )->				float:
    if height < 0 or radius < 0:
        raise ValueError("""vol_right_circ_cone() only accepts non-negative values"""       )
    return pi * pow(_lowerCAmelCase			,	2       ) * height / 3.0

def   a_					(_lowerCAmelCase  :   float			,	_lowerCAmelCase  :   float       )->				float:
    if height < 0 or area_of_base < 0:
        raise ValueError("""vol_prism() only accepts non-negative values"""       )
    return float(area_of_base * height       )

def   a_					(_lowerCAmelCase  :   float			,	_lowerCAmelCase  :   float       )->				float:
    if height < 0 or area_of_base < 0:
        raise ValueError("""vol_pyramid() only accepts non-negative values"""       )
    return area_of_base * height / 3.0

def   a_					(_lowerCAmelCase  :   float       )->				float:
    if radius < 0:
        raise ValueError("""vol_sphere() only accepts non-negative values"""       )
    # Volume is 4/3 * pi * radius cubed
    return 4 / 3 * pi * pow(_lowerCAmelCase			,	3       )

def   a_					(_lowerCAmelCase  :   float       )->				float:
    if radius < 0:
        raise ValueError("""vol_hemisphere() only accepts non-negative values"""       )
    # Volume is radius cubed * pi * 2/3
    return pow(_lowerCAmelCase			,	3       ) * pi * 2 / 3

def   a_					(_lowerCAmelCase  :   float			,	_lowerCAmelCase  :   float       )->				float:
    if height < 0 or radius < 0:
        raise ValueError("""vol_circular_cylinder() only accepts non-negative values"""       )
    # Volume is radius squared * height * pi
    return pow(_lowerCAmelCase			,	2       ) * height * pi

def   a_					(_lowerCAmelCase  :   float			,	_lowerCAmelCase  :   float			,	_lowerCAmelCase  :   float       )->				float:
    # Volume - (outer_radius squared - inner_radius squared) * pi * height
    if inner_radius < 0 or outer_radius < 0 or height < 0:
        raise ValueError(
            """vol_hollow_circular_cylinder() only accepts non-negative values"""       )
    if outer_radius <= inner_radius:
        raise ValueError("""outer_radius must be greater than inner_radius"""       )
    return pi * (pow(_lowerCAmelCase			,	2       ) - pow(_lowerCAmelCase			,	2       )) * height

def   a_					(_lowerCAmelCase  :   float			,	_lowerCAmelCase  :   float			,	_lowerCAmelCase  :   float       )->				float:
    # Volume is 1/3 * pi * height *
    #           (radius_1 squared + radius_2 squared + radius_1 * radius_2)
    if radius_a < 0 or radius_a < 0 or height < 0:
        raise ValueError("""vol_conical_frustum() only accepts non-negative values"""       )
    return (
        1
        / 3
        * pi
        * height
        * (pow(_lowerCAmelCase			,	2       ) + pow(_lowerCAmelCase			,	2       ) + radius_a * radius_a)
    )

def   a_					(_lowerCAmelCase  :   float			,	_lowerCAmelCase  :   float       )->				float:
    if torus_radius < 0 or tube_radius < 0:
        raise ValueError("""vol_torus() only accepts non-negative values"""       )
    return 2 * pow(_lowerCAmelCase			,	2       ) * torus_radius * pow(_lowerCAmelCase			,	2       )

def   a_					()->				Any:
    print("""Volumes:"""       )
    print(F"Cube: {vol_cube(2       ) = }"       )  # = 8
    print(F"Cuboid: {vol_cuboid(2			,	2			,	2       ) = }"       )  # = 8
    print(F"Cone: {vol_cone(2			,	2       ) = }"       )  # ~= 1.33
    print(F"Right Circular Cone: {vol_right_circ_cone(2			,	2       ) = }"       )  # ~= 8.38
    print(F"Prism: {vol_prism(2			,	2       ) = }"       )  # = 4
    print(F"Pyramid: {vol_pyramid(2			,	2       ) = }"       )  # ~= 1.33
    print(F"Sphere: {vol_sphere(2       ) = }"       )  # ~= 33.5
    print(F"Hemisphere: {vol_hemisphere(2       ) = }"       )  # ~= 16.75
    print(F"Circular Cylinder: {vol_circular_cylinder(2			,	2       ) = }"       )  # ~= 25.1
    print(F"Torus: {vol_torus(2			,	2       ) = }"       )  # ~= 157.9
    print(F"Conical Frustum: {vol_conical_frustum(2			,	2			,	4       ) = }"       )  # ~= 58.6
    print(F"Spherical cap: {vol_spherical_cap(1			,	2       ) = }"       )  # ~= 5.24
    print(F"Spheres intersetion: {vol_spheres_intersect(2			,	2			,	1       ) = }"       )  # ~= 21.21
    print(F"Spheres union: {vol_spheres_union(2			,	2			,	1       ) = }"       )  # ~= 45.81
    print(
        F"Hollow Circular Cylinder: {vol_hollow_circular_cylinder(1			,	2			,	3       ) = }"       )  # ~= 28.3


if __name__ == "__main__":
    main()



from __future__ import annotations

from statistics import mean

def   a_					(_lowerCAmelCase  :   list[int]       )->				list[int]:
    snake_case:						Tuple         =   2
    snake_case:						str         =   list(_lowerCAmelCase       )
    snake_case:						Union[str, Any]         =   [0] * len(_lowerCAmelCase       )
    snake_case:						List[Any]         =   0
    while True:
        snake_case:						Optional[int]         =   True
        for i, burst_time in enumerate(_lowerCAmelCase       ):
            if rem_burst_times[i] > 0:
                snake_case:						Dict         =   False
                if rem_burst_times[i] > quantum:
                    t += quantum
                    rem_burst_times[i] -= quantum
                else:
                    t += rem_burst_times[i]
                    snake_case:						Optional[Any]         =   t - burst_time
                    snake_case:						Tuple         =   0
        if done is True:
            return waiting_times

def   a_					(_lowerCAmelCase  :   list[int]			,	_lowerCAmelCase  :   list[int]       )->				list[int]:
    return [burst + waiting for burst, waiting in zip(_lowerCAmelCase			,	_lowerCAmelCase       )]


if __name__ == "__main__":
    __lowerCAmelCase    :  List[Any]										= [3, 5, 7]
    __lowerCAmelCase    :  List[Any]										= calculate_waiting_times(burst_times)
    __lowerCAmelCase    :  str										= calculate_turn_around_times(burst_times, waiting_times)
    print('Process ID \tBurst Time \tWaiting Time \tTurnaround Time')
    for i, burst_time in enumerate(burst_times):
        print(
            F"""  {i + 1}\t\t  {burst_time}\t\t  {waiting_times[i]}\t\t  """
            F"""{turn_around_times[i]}"""
        )
    print(F"""\nAverage waiting time = {mean(waiting_times):.5f}""")
    print(F"""Average turn around time = {mean(turn_around_times):.5f}""")


