






'''simple docstring'''

def     __lowercase  (_lowercase     )   ->     str:


					"""simple docstring"""
					__lowerCamelCase						:       Optional[int]				   =				""""""
					for ch in key:
										if ch == " " or ch not in key_no_dups and ch.isalpha():
															key_no_dups += ch
					return key_no_dups
def     __lowercase  (_lowercase     )   ->     dict[str, str]:


					"""simple docstring"""
					__lowerCamelCase						:       Optional[Any]				   =				[chr(i + 65     ) for i in range(26     )]
					# Remove duplicate characters from key
					__lowerCamelCase						:       str				   =				remove_duplicates(key.upper()     )
					__lowerCamelCase						:       Optional[int]				   =				len(UpperCAmelCase__     )
					# First fill cipher with key characters
					__lowerCamelCase						:       List[str]				   =				{alphabet[i]: char for i, char in enumerate(UpperCAmelCase__     )}
					# Then map remaining characters in alphabet to
					# the alphabet from the beginning
					for i in range(len(UpperCAmelCase__     ),						26     ):
										__lowerCamelCase						:       Optional[Any]				   =				alphabet[i - offset]
										# Ensure we are not mapping letters to letters previously mapped
										while char in key:
															offset -= 1
															__lowerCamelCase						:       List[str]				   =				alphabet[i - offset]
										__lowerCamelCase						:       List[str]				   =				char
					return cipher_alphabet
def     __lowercase  (_lowercase,						_lowercase     )   ->     str:


					"""simple docstring"""
					return "".join(cipher_map.get(UpperCAmelCase__,						UpperCAmelCase__     ) for ch in message.upper()     )
def     __lowercase  (_lowercase,						_lowercase     )   ->     str:


					"""simple docstring"""
					__lowerCamelCase						:       Optional[int]				   =				{v: k for k, v in cipher_map.items()}
					return "".join(rev_cipher_map.get(UpperCAmelCase__,						UpperCAmelCase__     ) for ch in message.upper()     )
def     __lowercase  ()   ->     None:


					"""simple docstring"""
					__lowerCamelCase						:       Tuple				   =				input("""Enter message to encode or decode: """     ).strip()
					__lowerCamelCase						:       Optional[int]				   =				input("""Enter keyword: """     ).strip()
					__lowerCamelCase						:       Tuple				   =				input("""Encipher or decipher? E/D:"""     ).strip()[0].lower()
					try:
										__lowerCamelCase						:       int				   =				{"""e""": encipher, """d""": decipher}[option]
					except KeyError:
										raise KeyError("""invalid input option"""     )
					__lowerCamelCase						:       List[Any]				   =				create_cipher_map(UpperCAmelCase__     )
					print(func(UpperCAmelCase__,						UpperCAmelCase__     )     )


if __name__ == "__main__":
			import doctest

			doctest.testmod()
			main()











'''simple docstring'''

def     __lowercase  (_lowercase     )   ->     list:


     """simple docstring"""

     # bit count represents no. of bits in the gray code
     if bit_count < 0:
          raise ValueError("""The given input must be positive"""     )

     # get the generated string sequence
     __lowerCamelCase						:       Optional[Any]				   =				gray_code_sequence_string(_lowercase     )
     #
     # convert them to integers
     for i in range(len(_lowercase     )     ):
          __lowerCamelCase						:       List[str]				   =				int(sequence[i],						2     )

     return sequence
def     __lowercase  (_lowercase     )   ->     list:


     """simple docstring"""

     # The approach is a recursive one
     # Base case achieved when either n = 0 or n=1
     if bit_count == 0:
          return ["0"]

     if bit_count == 1:
          return ["0", "1"]

     __lowerCamelCase						:       str				   =				1 << bit_count  # defines the length of the sequence
     # 1<< n is equivalent to 2^n

     # recursive answer will generate answer for n-1 bits
     __lowerCamelCase						:       Union[str, Any]				   =				gray_code_sequence_string(bit_count - 1     )

     __lowerCamelCase						:       Optional[int]				   =				[]

     # append 0 to first half of the smaller sequence generated
     for i in range(seq_len // 2     ):
          __lowerCamelCase						:       Union[str, Any]				   =				"""0""" + smaller_sequence[i]
          sequence.append(_lowercase     )

     # append 1 to second half ... start from the end of the list
     for i in reversed(range(seq_len // 2     )     ):
          __lowerCamelCase						:       Optional[Any]				   =				"""1""" + smaller_sequence[i]
          sequence.append(_lowercase     )

     return sequence


if __name__ == "__main__":
   import doctest

   doctest.testmod()



