



'''simple docstring'''
from __future__ import annotations

import random

from matplotlib import animation
from matplotlib import pyplot as plt

# Frame rate of the animation
_UpperCamelCase											=			20

# Time between time steps in seconds
_UpperCamelCase											=			INTERVAL / 1000



class _A  :





		def __init__(     self ,       __UpperCAmelCase ,       __UpperCAmelCase ,       __UpperCAmelCase ,       __UpperCAmelCase ,       __UpperCAmelCase = 1.0 ,       __UpperCAmelCase = 1.0 ,       __UpperCAmelCase = "blue" ,       )       ->     None:

					'''simple docstring'''
					__UpperCAmelCase   :      Dict										=     position_x
					__UpperCAmelCase   :      int										=     position_y
					__UpperCAmelCase   :      Dict										=     velocity_x
					__UpperCAmelCase   :      Any										=     velocity_y
					__UpperCAmelCase   :      Tuple										=     mass
					__UpperCAmelCase   :      List[str]										=     size
					__UpperCAmelCase   :      Any										=     color





		@property
		def 							__A       (     self				)       ->     tuple[float, float]:

					'''simple docstring'''
					return self.position_x, self.position_y





		@property
		def 							__A       (     self				)       ->     tuple[float, float]:

					'''simple docstring'''
					return self.velocity_x, self.velocity_y





		def 							__A       (     self ,       __UpperCAmelCase ,       __UpperCAmelCase ,       __UpperCAmelCase				)       ->     None:

					'''simple docstring'''
					self.velocity_x += force_x * delta_time
					self.velocity_y += force_y * delta_time





		def 							__A       (     self ,       __UpperCAmelCase				)       ->     None:

					'''simple docstring'''
					self.position_x += self.velocity_x * delta_time
					self.position_y += self.velocity_y * delta_time



class _A  :





		def __init__(     self ,       __UpperCAmelCase ,       __UpperCAmelCase = 1.0 ,       __UpperCAmelCase = 1.0 ,       __UpperCAmelCase = 0.0 ,       )       ->     None:

					'''simple docstring'''
					__UpperCAmelCase   :      str										=     bodies
					__UpperCAmelCase   :      List[Any]										=     gravitation_constant
					__UpperCAmelCase   :      Union[str, Any]										=     time_factor
					__UpperCAmelCase   :      int										=     softening_factor





		def __len__(     self				)       ->     int:

					'''simple docstring'''
					return len(self.bodies				)





		def 							__A       (     self ,       __UpperCAmelCase				)       ->     None:

					'''simple docstring'''
					for bodya in self.bodies:
								__UpperCAmelCase   :      Optional[int]										=     0.0
								__UpperCAmelCase   :      Any										=     0.0
								for bodya in self.bodies:
											if bodya != bodya:
														__UpperCAmelCase   :      List[Any]										=     bodya.position_x - bodya.position_x
														__UpperCAmelCase   :      Tuple										=     bodya.position_y - bodya.position_y

														# Calculation of the distance using Pythagoras's theorem
														# Extra factor due to the softening technique
														__UpperCAmelCase   :      Union[str, Any]										=     (dif_x**2 + dif_y**2 + self.softening_factor) ** (
														    1 / 2
														)

														# Newton's law of universal gravitation.
														force_x += (
														    self.gravitation_constant * bodya.mass * dif_x / distance**3
														)
														force_y += (
														    self.gravitation_constant * bodya.mass * dif_y / distance**3
														)

            # Update the body's velocity once all the force components have been added
								bodya.update_velocity(__UpperCAmelCase ,       __UpperCAmelCase ,       delta_time * self.time_factor				)

					# Update the positions only after all the velocities have been updated
					for body in self.bodies:
								body.update_position(delta_time * self.time_factor				)


def   lowercase_	(   lowerCAmelCase__	:  BodySystem			,							lowerCAmelCase__	:  float			,							lowerCAmelCase__	:  list[plt.Circle] ):

			"""simple docstring"""





			body_system.update_system(lowerCAmelCase__ )

			# Update the positions of the patches
			for patch, body in zip(lowerCAmelCase__			,							body_system.bodies ):
						__UpperCAmelCase   :      List[Any]										=     (body.position_x, body.position_y)


def   lowercase_	(   lowerCAmelCase__	:  str			,							lowerCAmelCase__	:  BodySystem			,							lowerCAmelCase__	:  float = -1			,							lowerCAmelCase__	:  float = 1			,							lowerCAmelCase__	:  float = -1			,							lowerCAmelCase__	:  float = 1			,							):

			"""simple docstring"""





			__UpperCAmelCase   :      List[str]										=     plt.figure()
			fig.canvas.set_window_title(lowerCAmelCase__ )
			__UpperCAmelCase   :      Union[str, Any]										=     plt.axes(
			    xlim=(x_start, x_end)			,							ylim=(y_start, y_end) )  # Set section to be plotted
			plt.gca().set_aspect("""equal""" )  # Fix aspect ratio

			# Each body is drawn as a patch by the plt-function
			__UpperCAmelCase   :      List[str]										=     [
			    plt.Circle((body.position_x, body.position_y)			,							body.size			,							fc=body.color )
			    for body in body_system.bodies
			]

			for patch in patches:
						ax.add_patch(lowerCAmelCase__ )

			# Function called at each step of the animation
			def update(lowerCAmelCase__	:  int ) -> list[plt.Circle]:
						update_step(lowerCAmelCase__			,							lowerCAmelCase__			,							lowerCAmelCase__ )
						return patches

			__UpperCAmelCase   :      Optional[Any]										=     animation.FuncAnimation(  # noqa: F841
			    lowerCAmelCase__			,							lowerCAmelCase__			,							interval=lowerCAmelCase__			,							blit=lowerCAmelCase__ )

			plt.show()


def   lowercase_	(   ):

			"""simple docstring"""





			__UpperCAmelCase   :      Union[str, Any]										=     0.9_700_436
			__UpperCAmelCase   :      str										=     -0.24_308_753
			__UpperCAmelCase   :      str										=     0.466_203_685
			__UpperCAmelCase   :      int										=     0.43_236_573

			__UpperCAmelCase   :      int										=     [
			    Body(lowerCAmelCase__			,							lowerCAmelCase__			,							lowerCAmelCase__			,							lowerCAmelCase__			,							size=0.2			,							color="""red""" ),
			    Body(-position_x			,							-position_y			,							lowerCAmelCase__			,							lowerCAmelCase__			,							size=0.2			,							color="""green""" ),
			    Body(0			,							0			,							-2 * velocity_x			,							-2 * velocity_y			,							size=0.2			,							color="""blue""" ),
			]
			return BodySystem(lowerCAmelCase__			,							time_factor=3 )


def   lowercase_	(   ):

			"""simple docstring"""





			__UpperCAmelCase   :      Optional[Any]										=     7.34_76E22
			__UpperCAmelCase   :      Tuple										=     5.9_72E24
			__UpperCAmelCase   :      Dict										=     1022
			__UpperCAmelCase   :      int										=     384399000
			__UpperCAmelCase   :      Any										=     6.6_74E-11

			# Calculation of the respective velocities so that total impulse is zero,
			# i.e. the two bodies together don't move
			__UpperCAmelCase   :      Union[str, Any]										=     earth_mass * velocity_dif / (earth_mass + moon_mass)
			__UpperCAmelCase   :      str										=     moon_velocity - velocity_dif

			__UpperCAmelCase   :      List[str]										=     Body(-earth_moon_distance			,							0			,							0			,							lowerCAmelCase__			,							lowerCAmelCase__			,							10000000			,							"""grey""" )
			__UpperCAmelCase   :      int										=     Body(0			,							0			,							0			,							lowerCAmelCase__			,							lowerCAmelCase__			,							50000000			,							"""blue""" )
			return BodySystem([earth, moon]			,							lowerCAmelCase__			,							time_factor=1000000 )


def   lowercase_	(   ):

			"""simple docstring"""





			__UpperCAmelCase   :      Optional[int]										=     []
			for _ in range(10 ):
						__UpperCAmelCase   :      str										=     random.uniform(-0.5			,							0.5 )
						__UpperCAmelCase   :      Union[str, Any]										=     random.uniform(-0.5			,							0.5 )

						# Bodies are created pairwise with opposite velocities so that the
						# total impulse remains zero
						bodies.append(
						    Body(
						        random.uniform(-0.5			,							0.5 )			,							random.uniform(-0.5			,							0.5 )			,							lowerCAmelCase__			,							lowerCAmelCase__			,							size=0.05			,							) )
						bodies.append(
						    Body(
						        random.uniform(-0.5			,							0.5 )			,							random.uniform(-0.5			,							0.5 )			,							-velocity_x			,							-velocity_y			,							size=0.05			,							) )
			return BodySystem(lowerCAmelCase__			,							0.01			,							10			,							0.1 )


if __name__ == "__main__":
					plot('''Figure-8 solution to the 3-body-problem''', example_a(), -2, 2, -2, 2)
					plot(
					    '''Moon\'s orbit around the earth''',
					    example_a(),
					    -4_3000_0000,
					    4_3000_0000,
					    -4_3000_0000,
					    4_3000_0000,
					)
					plot('''Random system with many bodies''', example_a(), -1.5, 1.5, -1.5, 1.5)









'''simple docstring'''
from itertools import permutations


def   lowercase_	(   lowerCAmelCase__	:  int = 5 ):

			"""simple docstring"""





			if gon_side < 3 or gon_side > 5:
						raise ValueError("""gon_side must be in the range [3, 5]""" )

			# Since it's 16, we know 10 is on the outer ring
			# Put the big numbers at the end so that they are never the first number
			__UpperCAmelCase   :      int										=     list(range(gon_side + 1			,							0			,							-1 ) )
			__UpperCAmelCase   :      int										=     list(range(gon_side + 2			,							gon_side * 2 + 1 ) )

			for perm in permutations(small_numbers + big_numbers ):
						__UpperCAmelCase   :      Optional[int]										=     generate_gon_ring(lowerCAmelCase__			,							list(lowerCAmelCase__ ) )
						if is_magic_gon(lowerCAmelCase__ ):
									return int("""""".join(str(lowerCAmelCase__ ) for n in numbers ) )

			__UpperCAmelCase   :      Optional[int]										=     f'Magic {gon_side}-gon ring is impossible'
			raise ValueError(lowerCAmelCase__ )


def   lowercase_	(   lowerCAmelCase__	:  int			,							lowerCAmelCase__	:  list[int] ):

			"""simple docstring"""





			__UpperCAmelCase   :      Tuple										=     [0] * (gon_side * 3)
			__UpperCAmelCase   :      Optional[Any]										=     perm[0:3]
			perm.append(perm[1] )

			__UpperCAmelCase   :      Union[str, Any]										=     1 if gon_side < 5 else 2

			for i in range(1			,							len(lowerCAmelCase__ ) // 3 + magic_number ):
						__UpperCAmelCase   :      List[str]										=     perm[2 * i + 1]
						__UpperCAmelCase   :      Optional[int]										=     result[3 * i - 1]
						__UpperCAmelCase   :      Optional[int]										=     perm[2 * i + 2]

			return result


def   lowercase_	(   lowerCAmelCase__	:  list[int] ):

			"""simple docstring"""





			if len(lowerCAmelCase__ ) % 3 != 0:
						raise ValueError("""a gon ring should have a length that is a multiple of 3""" )

			if min(numbers[::3] ) != numbers[0]:
						return False

			__UpperCAmelCase   :      Optional[int]										=     sum(numbers[:3] )

			return all(sum(numbers[i : i + 3] ) == total for i in range(3			,							len(lowerCAmelCase__ )			,							3 ) )


if __name__ == "__main__":
					print(solution())




