


'''simple docstring'''






from __future__ import annotations






def 		_A			(lowerCAmelCase__					:str			,  lowerCAmelCase__					:list[str] | None = None			,  lowerCAmelCase__					:dict[str, float] | None = None			,  lowerCAmelCase__					:bool = False			,  )				->					tuple[int, float, str]:




     '''simple docstring'''



     _a      =							cipher_alphabet or [chr(lowerCAmelCase__						) for i in range(97			,  1_23						)]

     # If the argument is None or the user provided an empty dictionary
     if not frequencies_dict:
          # Frequencies of letters in the english language (how much they show up)
          _a      =							{
              'a': 0.0_8_4_9_7,
              'b': 0.0_1_4_9_2,
              'c': 0.0_2_2_0_2,
              'd': 0.0_4_2_5_3,
              'e': 0.1_1_1_6_2,
              'f': 0.0_2_2_2_8,
              'g': 0.0_2_0_1_5,
              'h': 0.0_6_0_9_4,
              'i': 0.0_7_5_4_6,
              'j': 0.0_0_1_5_3,
              'k': 0.0_1_2_9_2,
              'l': 0.0_4_0_2_5,
              'm': 0.0_2_4_0_6,
              'n': 0.0_6_7_4_9,
              'o': 0.0_7_5_0_7,
              'p': 0.0_1_9_2_9,
              'q': 0.0_0_0_9_5,
              'r': 0.0_7_5_8_7,
              's': 0.0_6_3_2_7,
              't': 0.0_9_3_5_6,
              'u': 0.0_2_7_5_8,
              'v': 0.0_0_9_7_8,
              'w': 0.0_2_5_6_0,
              'x': 0.0_0_1_5_0,
              'y': 0.0_1_9_9_4,
              'z': 0.0_0_0_7_7,
          }
     else:
          # Custom frequencies dictionary
          _a      =							frequencies_dict

     if not case_sensitive:
          _a      =							ciphertext.lower()

     # Chi squared statistic values
     _a      =							{}

     # cycle through all of the shifts
     for shift in range(len(lowerCAmelCase__						)						):
          _a      =							''

          # decrypt the message with the shift
          for letter in ciphertext:
               try:
                    # Try to index the letter in the alphabet
                    _a      =							(alphabet_letters.index(letter.lower()						) - shift) % len(
                        lowerCAmelCase__						)
                    decrypted_with_shift += (
                        alphabet_letters[new_key].upper()
                        if case_sensitive and letter.isupper()
                        else alphabet_letters[new_key]
                    )
               except ValueError:
                    # Append the character if it isn't in the alphabet
                    decrypted_with_shift += letter

          _a      =							0.0

          # Loop through each letter in the decoded message with the shift
          for letter in decrypted_with_shift:
               if case_sensitive:
                    _a      =							letter.lower()
                    if letter in frequencies:
                         # Get the amount of times the letter occurs in the message
                         _a      =							decrypted_with_shift.lower().count(lowerCAmelCase__						)

                         # Get the excepcted amount of times the letter should appear based
                         # on letter frequencies
                         _a      =							frequencies[letter] * occurrences

                         # Complete the chi squared statistic formula
                         _a      =							((occurrences - expected) ** 2) / expected

                         # Add the margin of error to the total chi squared statistic
                         chi_squared_statistic += chi_letter_value
               else:
                    if letter.lower() in frequencies:
                         # Get the amount of times the letter occurs in the message
                         _a      =							decrypted_with_shift.count(lowerCAmelCase__						)

                         # Get the excepcted amount of times the letter should appear based
                         # on letter frequencies
                         _a      =							frequencies[letter] * occurrences

                         # Complete the chi squared statistic formula
                         _a      =							((occurrences - expected) ** 2) / expected

                         # Add the margin of error to the total chi squared statistic
                         chi_squared_statistic += chi_letter_value

        # Add the data to the chi_squared_statistic_values dictionary
          _a      =							(
              chi_squared_statistic,
              decrypted_with_shift,
          )

     # Get the most likely cipher by finding the cipher with the smallest chi squared
     # statistic
     def chi_squared_statistic_values_sorting_key(lowerCAmelCase__					:int						) -> tuple[float, str]:
          return chi_squared_statistic_values[key]

     _a      =							min(
         lowerCAmelCase__			,  key=lowerCAmelCase__			,  )

     # Get all the data from the most likely cipher (key, decoded message)
     (
         (
         _a
     ) ,				(
         _a
     ) ,				
     )      =							chi_squared_statistic_values[most_likely_cipher]

     # Return the data on the most likely shift
     return (
         most_likely_cipher,
         most_likely_cipher_chi_squared_value,
         decoded_most_likely_cipher,
     )





'''simple docstring'''






from timeit import timeit






def 		_A			(lowerCAmelCase__					:int						)				->					int:




     '''simple docstring'''



     if number < 0:
          raise ValueError('the value of input must not be negative'						)
     _a      =							0
     while number:
          number &= number - 1
          result += 1
     return result






def 		_A			(lowerCAmelCase__					:int						)				->					int:




     '''simple docstring'''



     if number < 0:
          raise ValueError('the value of input must not be negative'						)
     _a      =							0
     while number:
          if number % 2 == 1:
               result += 1
          number >>= 1
     return result






def 		_A			()				->					None:




     '''simple docstring'''



     def do_benchmark(lowerCAmelCase__					:int						) -> None:
          _a      =							'import __main__ as z'
          print(f'Benchmark when {number = }:'						)
          print(f'{get_set_bits_count_using_modulo_operator(lowerCAmelCase__						) = }'						)
          _a      =							timeit('z.get_set_bits_count_using_modulo_operator(25)'			,  setup=lowerCAmelCase__						)
          print(f'timeit() runs in {timing} seconds'						)
          print(f'{get_set_bits_count_using_brian_kernighans_algorithm(lowerCAmelCase__						) = }'						)
          _a      =							timeit(
              'z.get_set_bits_count_using_brian_kernighans_algorithm(25)'			,  setup=lowerCAmelCase__			,  )
          print(f'timeit() runs in {timing} seconds'						)

     for number in (25, 37, 58, 0):
          do_benchmark(lowerCAmelCase__						)
          print()


if __name__ == "__main__":
 import doctest

 doctest.testmod()
 benchmark()

