


'''simple docstring'''

from __future__ import annotations







class 			UpperCAmelCase			:

 def __init__(			self			:						List[str],       a_			:						int       ):





    """simple docstring"""



    UpperCamelCase__			    =    vertices
    UpperCamelCase__			    =    [[0] * vertices for _ in range(a_       )]

 def 		lowercase_    (			self			:						List[Any],       a_			:						list[int]       ):





    """simple docstring"""



    print("Vertex \t Distance from Source"       )
    for vertex in range(self.vertices       ):
       print(a_,       "\t\t",       distances_from_source[vertex]       )

 def 		lowercase_    (			self			:						List[Any],       a_			:						list[int],       a_			:						list[bool]       ):





    """simple docstring"""



    UpperCamelCase__			    =    1e7
    UpperCamelCase__			    =    0

    # Search not nearest vertex not in the shortest path tree
    for vertex in range(self.vertices       ):
       if distances_from_source[vertex] < minimum and visited[vertex] is False:
          UpperCamelCase__			    =    distances_from_source[vertex]
          UpperCamelCase__			    =    vertex
    return min_index

 def 		lowercase_    (			self			:						Optional[int],       a_			:						int       ):





    """simple docstring"""



    UpperCamelCase__			    =    [int(1e7       )] * self.vertices  # distances from the source
    UpperCamelCase__			    =    0
    UpperCamelCase__			    =    [False] * self.vertices

    for _ in range(self.vertices       ):
       UpperCamelCase__			    =    self.minimum_distance(a_,       a_       )
       UpperCamelCase__			    =    True

       # Update dist value of the adjacent vertices
       # of the picked vertex only if the current
       # distance is greater than new distance and
       # the vertex in not in the shortest path tree
       for v in range(self.vertices       ):
          if (
              self.graph[u][v] > 0
              and visited[v] is False
              and distances[v] > distances[u] + self.graph[u][v]
          ):
             UpperCamelCase__			    =    distances[u] + self.graph[u][v]

    self.print_solution(a_       )


if __name__ == "__main__":
       __lowercase:		Dict    						=  Graph(9)
       __lowercase:		List[str]    						=  [
           [0, 4, 0, 0, 0, 0, 0, 8, 0],
           [4, 0, 8, 0, 0, 0, 0, 11, 0],
           [0, 8, 0, 7, 0, 4, 0, 0, 2],
           [0, 0, 7, 0, 9, 14, 0, 0, 0],
           [0, 0, 0, 9, 0, 10, 0, 0, 0],
           [0, 0, 4, 14, 10, 0, 2, 0, 0],
           [0, 0, 0, 0, 0, 2, 0, 1, 6],
           [8, 11, 0, 0, 0, 0, 1, 0, 7],
           [0, 0, 2, 0, 0, 0, 6, 7, 0],
       ]
       graph.dijkstra(0)

from __future__ import annotations

from string import ascii_letters




def 		lowerCAmelCase_     (     _SCREAMING_SNAKE_CASE      ,	_SCREAMING_SNAKE_CASE      ,	_SCREAMING_SNAKE_CASE = None  )   ->      str:

							"""simple docstring"""






							_UpperCAmelCase  :			List[Any]	       =		alphabet or ascii_letters

							# The final result string
							_UpperCAmelCase  :			Optional[Any]	       =		""

							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
																					_UpperCAmelCase  :			Any	       =		(alpha.index(_SCREAMING_SNAKE_CASE  ) + key) % len(_SCREAMING_SNAKE_CASE  )

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

							return result




def 		lowerCAmelCase_     (     _SCREAMING_SNAKE_CASE      ,	_SCREAMING_SNAKE_CASE      ,	_SCREAMING_SNAKE_CASE = None  )   ->      str:

							"""simple docstring"""






							key *= -1

							return encrypt(_SCREAMING_SNAKE_CASE      ,	_SCREAMING_SNAKE_CASE      ,	_SCREAMING_SNAKE_CASE  )




def 		lowerCAmelCase_     (     _SCREAMING_SNAKE_CASE      ,	_SCREAMING_SNAKE_CASE = None  )   ->      dict[int, str]:

							"""simple docstring"""






							_UpperCAmelCase  :			Any	       =		alphabet or ascii_letters

							# To store data on all the combinations
							_UpperCAmelCase  :			Dict	       =		{}

							# Cycle through each combination
							for key in range(1      ,	len(_SCREAMING_SNAKE_CASE  ) + 1  ):
														# Decrypt the message and store the result in the data
														_UpperCAmelCase  :			Union[str, Any]	       =		decrypt(_SCREAMING_SNAKE_CASE      ,	_SCREAMING_SNAKE_CASE      ,	_SCREAMING_SNAKE_CASE  )

							return brute_force_data


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

								# get user input
								__lowerCamelCase								=					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":
												__lowerCamelCase								=					input('Please enter the string to be encrypted: ')
												__lowerCamelCase								=					int(input('Please enter off-set: ').strip())

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

												print(decrypt(input_string, key))
								elif choice == "3":
												__lowerCamelCase								=					input('Please enter the string to be decrypted: ')
												__lowerCamelCase								=					brute_force(input_string)

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

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




