




"""simple docstring"""

from __future__ import annotations

from string import ascii_letters




def    snake_case__						(							lowerCAmelCase :		str					,       lowerCAmelCase :		int					,       lowerCAmelCase :		str | None = None		):
					__snake_case        =						alphabet or ascii_letters

					# The final result string
					__snake_case        =						""""""

					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        =						(alpha.index(lowerCAmelCase		) + key) % len(lowerCAmelCase		)

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

					return result




def    snake_case__						(							lowerCAmelCase :		str					,       lowerCAmelCase :		int					,       lowerCAmelCase :		str | None = None		):
					key *= -1

					return encrypt(lowerCAmelCase					,       lowerCAmelCase					,       lowerCAmelCase		)




def    snake_case__						(							lowerCAmelCase :		str					,       lowerCAmelCase :		str | None = None		):
					__snake_case        =						alphabet or ascii_letters

					# To store data on all the combinations
					__snake_case        =						{}

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

					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
				UpperCamelCase__			:     List[str]			       =				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":
						UpperCamelCase__			:     str			       =				input("Please enter the string to be encrypted: ")
						UpperCamelCase__			:     Dict			       =				int(input("Please enter off-set: ").strip())

						print(encrypt(input_string, key))
				elif choice == "2":
						UpperCamelCase__			:     Any			       =				input("Please enter the string to be decrypted: ")
						UpperCamelCase__			:     List[Any]			       =				int(input("Please enter off-set: ").strip())

						print(decrypt(input_string, key))
				elif choice == "3":
						UpperCamelCase__			:     Optional[int]			       =				input("Please enter the string to be decrypted: ")
						UpperCamelCase__			:     Optional[int]			       =				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




def    snake_case__						(							lowerCAmelCase :		list[int]		):
					__snake_case        =						[0] * len(lowerCAmelCase		)
					for i in range(1					,       len(lowerCAmelCase		)		):
										__snake_case        =						duration_times[i - 1] + waiting_times[i - 1]
					return waiting_times




def    snake_case__						(							lowerCAmelCase :		list[int]					,       lowerCAmelCase :		list[int]		):
					return [
					    duration_time + waiting_times[i]
					    for i, duration_time in enumerate(lowerCAmelCase		)
					]




def    snake_case__						(							lowerCAmelCase :		list[int]		):
					return sum(lowerCAmelCase		) / len(lowerCAmelCase		)




def    snake_case__						(							lowerCAmelCase :		list[int]		):
					return sum(lowerCAmelCase		) / len(lowerCAmelCase		)


if __name__ == "__main__":
		# process id's
		UpperCamelCase__			:     str			       =				[1, 2, 3]

		# ensure that we actually have processes
		if len(processes) == 0:
				print("Zero amount of processes")
				raise SystemExit(0)

		# duration time of all processes
		UpperCamelCase__			:     Any			       =				[19, 8, 9]

		# ensure we can match each id to a duration time
		if len(duration_times) != len(processes):
				print("Unable to match all id's with their duration time")
				raise SystemExit(0)

		# get the waiting times and the turnaround times
		UpperCamelCase__			:     Optional[int]			       =				calculate_waiting_times(duration_times)
		UpperCamelCase__			:     Any			       =				calculate_turnaround_times(duration_times, waiting_times)

		# get the average times
		UpperCamelCase__			:     Optional[Any]			       =				calculate_average_waiting_time(waiting_times)
		UpperCamelCase__			:     Dict			       =				calculate_average_turnaround_time(turnaround_times)

		# print all the results
		print("Process ID\tDuration Time\tWaiting Time\tTurnaround Time")
		for i, process in enumerate(processes):
				print(
				    f'{process}\t\t{duration_times[i]}\t\t{waiting_times[i]}\t\t'
				    f'{turnaround_times[i]}'
				)
		print(f'Average waiting time = {average_waiting_time}')
		print(f'Average turn around time = {average_turnaround_time}')


