
from typing import Literal

__magic_name__           =					"ABCDEFGHIJKLMNOPQRSTUVWXYZ"





def 		SCREAMING_SNAKE_CASE__      ( __lowerCAmelCase      ,						__lowerCAmelCase      ,						__lowerCAmelCase							):
				snake_case__  =			LETTERS if mode == "decrypt" else key
				snake_case__  =			key if mode == "decrypt" else LETTERS
				snake_case__  =			""
				# loop through each symbol in the message
				for symbol in message:
								if symbol.upper() in chars_a:
												# encrypt/decrypt the symbol
												snake_case__  =			chars_a.find(symbol.upper()							)
												if symbol.isupper():
																translated += chars_b[sym_index].upper()
												else:
																translated += chars_b[sym_index].lower()
								else:
												# symbol is not in LETTERS, just add it
												translated += symbol
				return translated





def 		SCREAMING_SNAKE_CASE__      ( __lowerCAmelCase      ,						__lowerCAmelCase							):
				return translate_message(UpperCamelCase_      ,						UpperCamelCase_      ,						"encrypt"							)





def 		SCREAMING_SNAKE_CASE__      ( __lowerCAmelCase      ,						__lowerCAmelCase							):
				return translate_message(UpperCamelCase_      ,						UpperCamelCase_      ,						"decrypt"							)





def 		SCREAMING_SNAKE_CASE__      ( ):
				snake_case__  =			"Hello World"
				snake_case__  =			"QWERTYUIOPASDFGHJKLZXCVBNM"
				snake_case__  =			"decrypt"  # set to 'encrypt' or 'decrypt'

				if mode == "encrypt":
								snake_case__  =			encrypt_message(UpperCamelCase_      ,						UpperCamelCase_							)
				elif mode == "decrypt":
								snake_case__  =			decrypt_message(UpperCamelCase_      ,						UpperCamelCase_							)
				print(F"""Using the key {key}, the {mode}ed message is: {translated}"""							)


if __name__ == "__main__":
					import doctest

					doctest.testmod()
					main()





from __future__ import annotations

from abc import abstractmethod
from collections.abc import Iterable
from typing import Generic, Protocol, TypeVar




class    _SCREAMING_SNAKE_CASE					( __UpperCamelCase	):
      @abstractmethod
      def __lt__(     self						,		lowerCamelCase	):
          pass
      @abstractmethod
      def __gt__(     self						,		lowerCamelCase	):
          pass



      @abstractmethod
      def __eq__(     self						,		lowerCamelCase	):
          pass





__magic_name__           =					TypeVar('''T''', bound=Comparable)




class    _SCREAMING_SNAKE_CASE					( Generic[T]	):
      def __init__(     self	):
          snake_case__  =			[]
          snake_case__  =			0
      def __repr__(     self	):
          return str(self.h	)
      def A_     (     self						,		lowerCamelCase	):
          if child_idx > 0:
              return (child_idx - 1) // 2
          return None
      def A_     (     self						,		lowerCamelCase	):
          snake_case__  =			2 * parent_idx + 1
          if left_child_index < self.heap_size:
              return left_child_index
          return None
      def A_     (     self						,		lowerCamelCase	):
          snake_case__  =			2 * parent_idx + 2
          if right_child_index < self.heap_size:
              return right_child_index
          return None
      def A_     (     self						,		lowerCamelCase	):
          if index < self.heap_size:
              snake_case__  =			index
              snake_case__  =			self.left_child_idx(lowerCamelCase	)
              snake_case__  =			self.right_child_idx(lowerCamelCase	)
              # check which child is larger than its parent
              if left_child is not None and self.h[left_child] > self.h[violation]:
                  snake_case__  =			left_child
              if right_child is not None and self.h[right_child] > self.h[violation]:
                  snake_case__  =			right_child
              # if violation indeed exists
              if violation != index:
                  # swap to fix the violation
                  snake_case__  ,   snake_case__  =			self.h[index], self.h[violation]
                  # fix the subsequent violation recursively if any
                  self.max_heapify(lowerCamelCase	)
      def A_     (     self						,		lowerCamelCase	):
          snake_case__  =			list(lowerCamelCase	)
          snake_case__  =			len(self.h	)
          if self.heap_size > 1:
              # max_heapify from right to left but exclude leaves (last level)
              for i in range(self.heap_size // 2 - 1						,		-1						,		-1	):
                  self.max_heapify(lowerCamelCase	)
      def A_     (     self	):
          if self.heap_size >= 2:
              snake_case__  =			self.h[0]
              snake_case__  =			self.h.pop(-1	)
              self.heap_size -= 1
              self.max_heapify(0	)
              return me
          elif self.heap_size == 1:
              self.heap_size -= 1
              return self.h.pop(-1	)
          else:
              raise Exception("Empty heap"	)
      def A_     (     self						,		lowerCamelCase	):
          self.h.append(lowerCamelCase	)
          snake_case__  =			(self.heap_size - 1) // 2
          self.heap_size += 1
          while idx >= 0:
              self.max_heapify(lowerCamelCase	)
              snake_case__  =			(idx - 1) // 2



      def A_     (     self	):
          snake_case__  =			self.heap_size
          for j in range(size - 1						,		0						,		-1	):
              snake_case__  ,   snake_case__  =			self.h[j], self.h[0]
              self.heap_size -= 1
              self.max_heapify(0	)
          snake_case__  =			size


if __name__ == "__main__":
     import doctest

     # run doc test
     doctest.testmod()

     # demo
     for unsorted in [
         [0],
         [2],
         [3, 5],
         [5, 3],
         [5, 5],
         [0, 0, 0, 0],
         [1, 1, 1, 1],
         [2, 2, 3, 5],
         [0, 2, 2, 3, 5],
         [2, 5, 3, 0, 2, 3, 0, 3],
         [6, 1, 2, 7, 9, 3, 4, 5, 10, 8],
         [103, 9, 1, 7, 11, 15, 25, 201, 209, 107, 5],
         [-45, -2, -5],
     ]:
          print(F'''unsorted array: {unsorted}''')

          __magic_name__           =					Heap()
          heap.build_max_heap(unsorted)
          print(F'''after build heap: {heap}''')

          print(F'''max value: {heap.extract_max()}''')
          print(F'''after max value removed: {heap}''')

          heap.insert(100)
          print(F'''after new value 100 inserted: {heap}''')

          heap.heap_sort()
          print(F'''heap-sorted array: {heap}\n''')



