



'''simple docstring'''



from __future__ import annotations

from string import ascii_letters


def 							__UpperCAmelCase				(				UpperCamelCase__				:str   ,				UpperCamelCase__				:int   ,				UpperCamelCase__				:str | None = None			)		->						str:
				snake_case__      :   Dict      =    alphabet or ascii_letters

				# The final result string
				snake_case__      :   Dict      =    ''''''

				for character in input_string:
								if character not in alpha:
												# Append without encryption if character is not in the alphabet
												result += character
								else:
												# Get the index of the new key and make sure it isn't too large
												snake_case__      :   List[str]      =    (alpha.index(UpperCamelCase__			) + key) % len(UpperCamelCase__			)

												# Append the encoded character to the alphabet
												result += alpha[new_key]

				return result


def 							__UpperCAmelCase				(				UpperCamelCase__				:str   ,				UpperCamelCase__				:int   ,				UpperCamelCase__				:str | None = None			)		->						str:
				key *= -1

				return encrypt(UpperCamelCase__   ,				UpperCamelCase__   ,				UpperCamelCase__			)


def 							__UpperCAmelCase				(				UpperCamelCase__				:str   ,				UpperCamelCase__				:str | None = None			)		->						dict[int, str]:
				snake_case__      :   str      =    alphabet or ascii_letters

				# To store data on all the combinations
				snake_case__      :   Optional[int]      =    {}

				# Cycle through each combination
				for key in range(1   ,				len(UpperCamelCase__			) + 1			):
								# Decrypt the message and store the result in the data
								snake_case__      :   str      =    decrypt(UpperCamelCase__   ,				UpperCamelCase__   ,				UpperCamelCase__			)

				return brute_force_data


if __name__ == "__main__":
				while True:
								print(F"\n{'-' * 10}\n Menu\n{'-' * 10}")
								print(*["1.Encrypt", "2.Decrypt", "3.BruteForce", "4.Quit"], sep="\n")

								# get user input
								_lowercase       :						Optional[Any]						=input("\nWhat would you like to do?: ").strip() or "4"

								# run functions based on what the user chose
								if choice not in ("1", "2", "3", "4"):
												print("Invalid choice, please enter a valid choice")
								elif choice == "1":
												_lowercase       :						List[str]						=input("Please enter the string to be encrypted: ")
												_lowercase       :						Tuple						=int(input("Please enter off-set: ").strip())

												print(encrypt(input_string, key))
								elif choice == "2":
												_lowercase       :						Dict						=input("Please enter the string to be decrypted: ")
												_lowercase       :						int						=int(input("Please enter off-set: ").strip())

												print(decrypt(input_string, key))
								elif choice == "3":
												_lowercase       :						Tuple						=input("Please enter the string to be decrypted: ")
												_lowercase       :						List[Any]						=brute_force(input_string)

												for key, value in brute_force_data.items():
																print(F"Key: {key} | Message: {value}")

								elif choice == "4":
												print("Goodbye.")
												break









'''simple docstring'''



from __future__ import annotations

# Define the Gravitational Constant G and the function
_lowercase       :						List[str]						=6.6743E-11  # unit of G : m^3 * kg^-1 * s^-2


def 							__UpperCAmelCase				(				UpperCamelCase__				:float   ,				UpperCamelCase__				:float   ,				UpperCamelCase__				:float   ,				UpperCamelCase__				:float			)		->						dict[str, float]:
				snake_case__      :   str      =    mass_a * mass_a

				if (force, mass_a, mass_a, distance).count(0			) != 1:
								raise ValueError('''One and only one argument must be 0'''			)
				if force < 0:
								raise ValueError('''Gravitational force can not be negative'''			)
				if distance < 0:
								raise ValueError('''Distance can not be negative'''			)
				if mass_a < 0 or mass_a < 0:
								raise ValueError('''Mass can not be negative'''			)
				if force == 0:
								snake_case__      :   Dict      =    GRAVITATIONAL_CONSTANT * product_of_mass / (distance**2)
								return {"force": force}
				elif mass_a == 0:
								snake_case__      :   List[str]      =    (force) * (distance**2) / (GRAVITATIONAL_CONSTANT * mass_a)
								return {"mass_1": mass_a}
				elif mass_a == 0:
								snake_case__      :   List[Any]      =    (force) * (distance**2) / (GRAVITATIONAL_CONSTANT * mass_a)
								return {"mass_2": mass_a}
				elif distance == 0:
								snake_case__      :   str      =    (GRAVITATIONAL_CONSTANT * product_of_mass / (force)) ** 0.5
								return {"distance": distance}
				raise ValueError('''One and only one argument must be 0'''			)


# Run doctest
if __name__ == "__main__":
				import doctest

				doctest.testmod()




