code: 
  
  
  
  
  
  
  """simple docstring"""
  
  
  
  
  
  
  from string import ascii_uppercase
  
  
  
  
  def 						_UpperCamelCase			(  A    ,       A    ,       A = False    ,       A = ascii_uppercase			):
  			UpperCamelCase_     =keyword.upper()
  			UpperCamelCase_     =plaintext.upper()
  			UpperCamelCase_     =set(lowercase__			)
  
  			# create a list of unique characters in the keyword - their order matters
  			# it determines how we will map plaintext characters to the ciphertext
  			UpperCamelCase_     =[]
  			for char in keyword:
  						if char in alphabet_set and char not in unique_chars:
  									unique_chars.append(lowercase__			)
      # the number of those unique characters will determine the number of rows
  			UpperCamelCase_     =len(lowercase__			)
  
  			# create a shifted version of the alphabet
  			UpperCamelCase_     =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_     =[
  			    shifted_alphabet[k : k + num_unique_chars_in_keyword]
  			    for k in range(0    ,       26    ,       lowercase__			)
  			]
  
  			# map the alphabet characters to the modified alphabet characters
  			# going 'vertically' through the modified alphabet - consider columns first
  			UpperCamelCase_     ={}
  			UpperCamelCase_     =0
  			for column in range(lowercase__			):
  						for row in modified_alphabet:
  									# if current row (the last one) is too short, break out of loop
  									if len(lowercase__			) <= column:
  												break
  
  									# map current letter to letter in modified alphabet
  									UpperCamelCase_     =row[column]
  									letter_index += 1
  
  			if verbose:
  						print(lowercase__			)
  			# 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"))
  
style_context: 
  
  
  
  
  
  
  """simple docstring"""
  
  
  
  
  
  
  from .hash_table import HashTable
  from .number_theory.prime_numbers import is_prime, next_prime
  class 						__lowerCAmelCase   (			UpperCAmelCase       ):
  
  
  
  
  
  
  
    '''simple docstring'''
  
  
    def __init__(      self:		List[Any]				,			*UpperCamelCase_:		Dict				,			**UpperCamelCase_:		Optional[int]					):
       super().__init__(*UpperCamelCase_				,			**UpperCamelCase_					)
    def 					UpperCamelCase__   (      self:		Any				,			UpperCamelCase_:		Optional[int]				,			UpperCamelCase_:		Optional[int]					):
       UpperCamelCase_     =(
           next_prime(value % self.size_table					)
           if not is_prime(value % self.size_table					)
           else value % self.size_table
       )  # gt = bigger than
       return next_prime_gt - (data % next_prime_gt)
    def 					UpperCamelCase__   (      self:		str				,			UpperCamelCase_:		List[str]				,			UpperCamelCase_:		str				,			UpperCamelCase_:		Tuple					):
       return (increment * self.__hash_function_a(UpperCamelCase_				,			UpperCamelCase_					)) % self.size_table
  
  
  
  
  
    def 					UpperCamelCase__   (      self:		str				,			UpperCamelCase_:		int				,			UpperCamelCase_:		str=None					):
       UpperCamelCase_     =1
       UpperCamelCase_     =self.hash_function(UpperCamelCase_					)
  
       while self.values[new_key] is not None and self.values[new_key] != key:
          UpperCamelCase_     =(
              self.__hash_double_function(UpperCamelCase_				,			UpperCamelCase_				,			UpperCamelCase_					)
              if self.balanced_factor() >= self.lim_charge
              else None
          )
          if new_key is None:
             break
          else:
             i += 1
  
       return new_key
  