

UpperCAmelCase     						=			(1, 1_53, 3_70, 3_71, 16_34, 24_67_80_51, 1_15_13_22_19_01_87_63_99_25_65_09_55_97_97_39_71_52_24_01)
UpperCAmelCase     						=			(-1_53, -1, 0, 1.2, 2_00, '''A''', [], {}, None)


def SCREAMING_SNAKE_CASE			(       lowercase_:		int			):
       if not isinstance(lowercase_						,  lowercase_			) or n < 1:
              return False

       # Initialization of sum and number of digits.
       _UpperCamelCase       :    str					  =					0
       _UpperCamelCase       :    Union[str, Any]					  =					0
       _UpperCamelCase       :    str					  =					n
       # Calculation of digits of the number
       while temp > 0:
              number_of_digits += 1
              temp //= 10
       # Dividing number into separate digits and find Armstrong number
       _UpperCamelCase       :    Dict					  =					n
       while temp > 0:
              _UpperCamelCase       :    str					  =					temp % 10
              total += rem**number_of_digits
              temp //= 10
       return n == total


def SCREAMING_SNAKE_CASE			(       lowercase_:		int			):
       if not isinstance(lowercase_						,  lowercase_			) or n < 1:
              return False

       # Init a "histogram" of the digits
       _UpperCamelCase       :    Tuple					  =					[0, 0, 0, 0, 0, 0, 0, 0, 0, 0]
       _UpperCamelCase       :    Optional[Any]					  =					0
       _UpperCamelCase       :    Optional[int]					  =					0
       _UpperCamelCase       :    Dict					  =					n
       while temp > 0:
              _UpperCamelCase       :    Optional[int]					  =					divmod(lowercase_						,  10			)
              digit_histogram[rem] += 1
              digit_total += 1

       for cnt, i in zip(lowercase_						,  range(len(lowercase_			)			)			):
              total += cnt * i**digit_total

       return n == total


def SCREAMING_SNAKE_CASE			(       lowercase_:		int			):
       if not isinstance(lowercase_						,  lowercase_			) or n < 1:
              return False
       _UpperCamelCase       :    Union[str, Any]					  =					len(str(lowercase_			)			)  # the power that all digits will be raised to
       # check if sum of each digit multiplied expo times is equal to number
       return n == sum(int(lowercase_			) ** expo for i in str(lowercase_			)			)


def SCREAMING_SNAKE_CASE			(       ):
       _UpperCamelCase       :    List[str]					  =					int(input('Enter an integer to see if it is an Armstrong number: '			).strip()			)
       print(F"{num} is {'' if armstrong_number(lowercase_			) else 'not '}an Armstrong number."			)
       print(F"{num} is {'' if narcissistic_number(lowercase_			) else 'not '}an Armstrong number."			)
       print(F"{num} is {'' if pluperfect_number(lowercase_			) else 'not '}an Armstrong number."			)


if __name__ == "__main__":
 import doctest

 doctest.testmod()
 main()




def SCREAMING_SNAKE_CASE			(       lowercase_:		int			):
       if not isinstance(lowercase_						,  lowercase_			):
              _UpperCamelCase       :    Optional[int]					  =					(
                  'operation can not be conducted on a object of type '
                  F"{type(lowercase_			).__name__}"
              )
              raise TypeError(lowercase_			)
       _UpperCamelCase       :    List[Any]					  =					''
       for _ in range(0						,  32			):
              bit_string += str(number % 2			)
              _UpperCamelCase       :    Dict					  =					number >> 1
       return bit_string


def SCREAMING_SNAKE_CASE			(       lowercase_:		int			):
       if number < 0:
              raise ValueError('the value of input must be positive'			)
       elif isinstance(lowercase_						,  lowercase_			):
              raise TypeError('Input value must be a \'int\' type'			)
       elif isinstance(lowercase_						,  lowercase_			):
              raise TypeError('\'<\' not supported between instances of \'str\' and \'int\''			)
       _UpperCamelCase       :    List[Any]					  =					0
       # iterator over [1 to 32],since we are dealing with 32 bit integer
       for _ in range(1						,  33			):
              # left shift the bits by unity
              _UpperCamelCase       :    Tuple					  =					result << 1
              # get the end bit
              _UpperCamelCase       :    List[Any]					  =					number % 2
              # right shift the bits by unity
              _UpperCamelCase       :    Dict					  =					number >> 1
              # add that bit to our ans
              _UpperCamelCase       :    int					  =					result | end_bit
       return get_reverse_bit_string(lowercase_			)


if __name__ == "__main__":
 import doctest

 doctest.testmod()



