




'''simple docstring'''




def      a_							(      __snake_case							:			str   )							->						str:



       """simple docstring"""
       lowerCamelCase_							=''''''
       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      a_							(      __snake_case							:			str   )							->						dict[str, str]:



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





def      a_							(      __snake_case							:			str   ,       __snake_case							:			dict[str, str]   )							->						str:



       """simple docstring"""
       return "".join(cipher_map.get(__snake_case   ,       __snake_case   ) for ch in message.upper()   )





def      a_							(      __snake_case							:			str   ,       __snake_case							:			dict[str, str]   )							->						str:



       """simple docstring"""
       lowerCamelCase_							={v: k for k, v in cipher_map.items()}
       return "".join(rev_cipher_map.get(__snake_case   ,       __snake_case   ) for ch in message.upper()   )





def      a_							(      )							->						None:



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


if __name__ == "__main__":
     import doctest

     doctest.testmod()
     main()











import numpy as np
from PIL import Image



def _a				(	lowerCamelCase:   np.ndarray					,				lowerCamelCase:   int					,				lowerCamelCase:   int )	->						np.ndarray:







      '''simple docstring'''






      __A          =				np.array(lowerCamelCase )
      if arr.shape[0] != arr.shape[1]:
            raise ValueError('''The input array is not a square matrix''' )
      __A          =				0
      __A          =				0
      __A          =				0
      __A          =				0

      # compute the shape of the output matrix
      __A          =				(arr.shape[0] - size) // stride + 1
      # initialize the output matrix with zeros of shape maxpool_shape
      __A          =				np.zeros((maxpool_shape, maxpool_shape) )

      while i < arr.shape[0]:
            if i + size > arr.shape[0]:
                  # if the end of the matrix is reached, break
                  break
            while j < arr.shape[1]:
                  # if the end of the matrix is reached, break
                  if j + size > arr.shape[1]:
                        break
                  # compute the maximum of the pooling matrix
                  __A          =				np.max(arr[i : i + size, j : j + size] )
                  # shift the pooling matrix by stride of column pixels
                  j += stride
                  mat_j += 1

            # shift the pooling matrix by stride of row pixels
            i += stride
            mat_i += 1

            # reset the column index to 0
            __A          =				0
            __A          =				0

      return updated_arr



def _a				(	lowerCamelCase:   np.ndarray					,				lowerCamelCase:   int					,				lowerCamelCase:   int )	->						np.ndarray:







      '''simple docstring'''






      __A          =				np.array(lowerCamelCase )
      if arr.shape[0] != arr.shape[1]:
            raise ValueError('''The input array is not a square matrix''' )
      __A          =				0
      __A          =				0
      __A          =				0
      __A          =				0

      # compute the shape of the output matrix
      __A          =				(arr.shape[0] - size) // stride + 1
      # initialize the output matrix with zeros of shape avgpool_shape
      __A          =				np.zeros((avgpool_shape, avgpool_shape) )

      while i < arr.shape[0]:
            # if the end of the matrix is reached, break
            if i + size > arr.shape[0]:
                  break
            while j < arr.shape[1]:
                  # if the end of the matrix is reached, break
                  if j + size > arr.shape[1]:
                        break
                  # compute the average of the pooling matrix
                  __A          =				int(np.average(arr[i : i + size, j : j + size] ) )
                  # shift the pooling matrix by stride of column pixels
                  j += stride
                  mat_j += 1

            # shift the pooling matrix by stride of row pixels
            i += stride
            mat_i += 1
            # reset the column index to 0
            __A          =				0
            __A          =				0

      return updated_arr


# Main Function
if __name__ == "__main__":
       from doctest import testmod

       testmod(name='avgpooling', verbose=True)

       # Loading the image
       snake_case__					:							Optional[Any]													=     Image.open('path_to_image')

       # Converting the image to numpy array and maxpooling, displaying the result
       # Ensure that the image is a square matrix

       Image.fromarray(maxpooling(np.array(image), size=3, stride=2)).show()

       # Converting the image to numpy array and averagepooling, displaying the result
       # Ensure that the image is a square matrix

       Image.fromarray(avgpooling(np.array(image), size=3, stride=2)).show()





