




from string import ascii_uppercase
def 							__lowerCAmelCase			(UpperCAmelCase_ ,     UpperCAmelCase_ ,     UpperCAmelCase_ = False ,     UpperCAmelCase_ = ascii_uppercase		):
    a__  			=							keyword.upper()
    a__  			=							plaintext.upper()
    a__  			=							set(UpperCAmelCase_		)

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

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

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

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

            # map current letter to letter in modified alphabet
            a__  			=							row[column]
            letter_index += 1

    if verbose:
        print(UpperCAmelCase_		)
    # 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'''))












from __future__ import annotations

import random







class 		__UpperCAmelCase:





     """simple docstring"""



     __UpperCAmelCase						:			Optional[int]							=     6

     def __init__(   self			:							int     )      ->      Optional[Any]:






         """simple docstring"""
         a__  			=							list(range(1    ,					Dice.NUM_SIDES + 1     )     )






     def 					__SCREAMING_SNAKE_CASE		(   self			:							Union[str, Any]     )      ->      List[str]:






         """simple docstring"""
         return random.choice(self.sides     )






def 							__lowerCAmelCase			(UpperCAmelCase_ ,     UpperCAmelCase_ = 2		):
    a__  			=							[Dice() for i in range(UpperCAmelCase_		)]
    a__  			=							[0] * (len(UpperCAmelCase_		) * Dice.NUM_SIDES + 1)
    for _ in range(UpperCAmelCase_		):
        count_of_sum[sum(dice.roll() for dice in dices		)] += 1
    a__  			=							[round((count * 100) / num_throws ,     2		) for count in count_of_sum]
    return probability[num_dice:]  # remove probability of sums that never appear


if __name__ == "__main__":
 import doctest

 doctest.testmod()






