





from __future__ import annotations

from math import pi, pow







def    UpperCAmelCase				(  _lowerCamelCase   :	Any  ):





						'''simple docstring'''


						if side_length < 0:
												raise ValueError("vol_cube() only accepts non-negative values"  )
						return pow(_SCREAMING_SNAKE_CASE      , 3  )







def    UpperCAmelCase				(  _lowerCamelCase   :	Tuple      , _lowerCamelCase   :	Dict  ):





						'''simple docstring'''


						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(_SCREAMING_SNAKE_CASE      , 2  ) * (3 * radius - height)







def    UpperCAmelCase				(  _lowerCamelCase   :	Any      , _lowerCamelCase   :	Optional[Any]      , _lowerCamelCase   :	Union[str, Any]  ):





						'''simple docstring'''


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

						SCREAMING_SNAKE_CASE__  :					Dict =       (
						    (radius_a - radius_a + centers_distance)
						    * (radius_a + radius_a - centers_distance)
						    / (2 * centers_distance)
						)
						SCREAMING_SNAKE_CASE__  :					List[Any] =       (
						    (radius_a - radius_a + centers_distance)
						    * (radius_a + radius_a - centers_distance)
						    / (2 * centers_distance)
						)

						return vol_spherical_cap(_SCREAMING_SNAKE_CASE      , _SCREAMING_SNAKE_CASE  ) + vol_spherical_cap(_SCREAMING_SNAKE_CASE      , _SCREAMING_SNAKE_CASE  )







def    UpperCAmelCase				(  _lowerCamelCase   :	Tuple      , _lowerCamelCase   :	Dict      , _lowerCamelCase   :	Any  ):





						'''simple docstring'''


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

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







def    UpperCAmelCase				(  _lowerCamelCase   :	int      , _lowerCamelCase   :	Any      , _lowerCamelCase   :	Any  ):





						'''simple docstring'''


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







def    UpperCAmelCase				(  _lowerCamelCase   :	List[str]      , _lowerCamelCase   :	str  ):





						'''simple docstring'''


						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    UpperCAmelCase				(  _lowerCamelCase   :	Any      , _lowerCamelCase   :	Dict  ):





						'''simple docstring'''


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







def    UpperCAmelCase				(  _lowerCamelCase   :	List[Any]      , _lowerCamelCase   :	Optional[int]  ):





						'''simple docstring'''


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







def    UpperCAmelCase				(  _lowerCamelCase   :	List[str]      , _lowerCamelCase   :	int  ):





						'''simple docstring'''


						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    UpperCAmelCase				(  _lowerCamelCase   :	Dict  ):





						'''simple docstring'''


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







def    UpperCAmelCase				(  _lowerCamelCase   :	int  ):





						'''simple docstring'''


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







def    UpperCAmelCase				(  _lowerCamelCase   :	str      , _lowerCamelCase   :	List[str]  ):





						'''simple docstring'''


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







def    UpperCAmelCase				(  _lowerCamelCase   :	List[str]      , _lowerCamelCase   :	str      , _lowerCamelCase   :	int  ):





						'''simple docstring'''


						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(_SCREAMING_SNAKE_CASE      , 2  ) - pow(_SCREAMING_SNAKE_CASE      , 2  )) * height







def    UpperCAmelCase				(  _lowerCamelCase   :	List[Any]      , _lowerCamelCase   :	Tuple      , _lowerCamelCase   :	Optional[Any]  ):





						'''simple docstring'''


						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(_SCREAMING_SNAKE_CASE      , 2  ) + pow(_SCREAMING_SNAKE_CASE      , 2  ) + radius_a * radius_a)
						)







def    UpperCAmelCase				(  _lowerCamelCase   :	Optional[int]      , _lowerCamelCase   :	int  ):





						'''simple docstring'''


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







def    UpperCAmelCase				(  ):





						'''simple docstring'''


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







"""simple docstring"""



from string import ascii_uppercase




def       snake_case__		(   _SCREAMING_SNAKE_CASE       ,	_SCREAMING_SNAKE_CASE       ,	_SCREAMING_SNAKE_CASE = False       ,	_SCREAMING_SNAKE_CASE = ascii_uppercase			)    ->str:
 UpperCAmelCase__ 						=				keyword.upper()
 UpperCAmelCase__ 						=				plaintext.upper()
 UpperCAmelCase__ 						=				set(_SCREAMING_SNAKE_CASE			)

 # create a list of unique characters in the keyword - their order matters
 # it determines how we will map plaintext characters to the ciphertext
 UpperCAmelCase__ 						=				[]
 for char in keyword:
  if char in alphabet_set and char not in unique_chars:
   unique_chars.append(_SCREAMING_SNAKE_CASE			)
    # the number of those unique characters will determine the number of rows
 UpperCAmelCase__ 						=				len(_SCREAMING_SNAKE_CASE			)

 # create a shifted version of the alphabet
 UpperCAmelCase__ 						=				unique_chars + [
     char for char in alphabet if char not in unique_chars
 ]

 # create a modified alphabet by splitting the shifted alphabet into rows
 UpperCAmelCase__ 						=				[
     shifted_alphabet[k : k + num_unique_chars_in_keyword]
     for k in range(0       ,	2_6       ,	_SCREAMING_SNAKE_CASE			)
 ]

 # map the alphabet characters to the modified alphabet characters
 # going 'vertically' through the modified alphabet - consider columns first
 UpperCAmelCase__ 						=				{}
 UpperCAmelCase__ 						=				0
 for column in range(_SCREAMING_SNAKE_CASE			):
  for row in modified_alphabet:
   # if current row (the last one) is too short, break out of loop
   if len(_SCREAMING_SNAKE_CASE			) <= column:
    break

   # map current letter to letter in modified alphabet
   UpperCAmelCase__ 						=				row[column]
   letter_index += 1

 if verbose:
  print(_SCREAMING_SNAKE_CASE			)
 # create the encrypted text by mapping the plaintext to the modified alphabet
 return "".join(mapping[char] if char in mapping else char for char in plaintext			)


if __name__ == "__main__":
 # example use
 print(mixed_keyword('''college''', '''UNIVERSITY'''))



