
"""simple docstring"""




from string import ascii_uppercase



def 				a__			(					lowerCAmelCase						:							str							,     lowerCAmelCase						:							str							,     lowerCAmelCase						:							bool = False							,     lowerCAmelCase						:							str = ascii_uppercase		):






     '''simple docstring'''
     UpperCAmelCase__				:			Tuple							=    keyword.upper()
     UpperCAmelCase__				:			Tuple							=    plaintext.upper()
     UpperCAmelCase__				:			Optional[Any]							=    set(lowerCAmelCase		)

     # create a list of unique characters in the keyword - their order matters
     # it determines how we will map plaintext characters to the ciphertext
     UpperCAmelCase__				:			Tuple							=    []
     for char in keyword:
          if char in alphabet_set and char not in unique_chars:
               unique_chars.append(lowerCAmelCase		)
    # the number of those unique characters will determine the number of rows
     UpperCAmelCase__				:			List[str]							=    len(lowerCAmelCase		)

     # create a shifted version of the alphabet
     UpperCAmelCase__				:			Tuple							=    unique_chars + [
         char for char in alphabet if char not in unique_chars
     ]

     # create a modified alphabet by splitting the shifted alphabet into rows
     UpperCAmelCase__				:			List[Any]							=    [
         shifted_alphabet[k : k + num_unique_chars_in_keyword]
         for k in range(0							,     26							,     lowerCAmelCase		)
     ]

     # map the alphabet characters to the modified alphabet characters
     # going 'vertically' through the modified alphabet - consider columns first
     UpperCAmelCase__				:			List[str]							=    {}
     UpperCAmelCase__				:			Tuple							=    0
     for column in range(lowerCAmelCase		):
          for row in modified_alphabet:
               # if current row (the last one) is too short, break out of loop
               if len(lowerCAmelCase		) <= column:
                    break

               # map current letter to letter in modified alphabet
               UpperCAmelCase__				:			Optional[Any]							=    row[column]
               letter_index += 1

     if verbose:
          print(lowerCAmelCase		)
     # create the encrypted text by mapping the plaintext to the modified alphabet
     return "".join(mapping[char] if char in mapping else char for char in plaintext		)


if __name__ == "__main__":
    # example use
    print(mixed_keyword("""college""", """UNIVERSITY"""))





"""simple docstring"""




def 				a__			(					lowerCAmelCase						:							int		):






     '''simple docstring'''
     if number != int(lowerCAmelCase		):
          raise ValueError("factorial() only accepts integral values"		)
     if number < 0:
          raise ValueError("factorial() not defined for negative values"		)
     UpperCAmelCase__				:			int							=    1
     for i in range(1							,     number + 1		):
          value *= i
     return value



def 				a__			(					lowerCAmelCase						:							int		):






     '''simple docstring'''
     if not isinstance(lowerCAmelCase							,     lowerCAmelCase		):
          raise ValueError("factorial() only accepts integral values"		)
     if n < 0:
          raise ValueError("factorial() not defined for negative values"		)
     return 1 if n == 0 or n == 1 else n * factorial(n - 1		)


if __name__ == "__main__":
    import doctest

    doctest.testmod()

    A__   :						Any 							=     int(input("""Enter a positive integer: """).strip() or 0)
    print(f"""factorial{n} is {factorial(n)}""")



