






a	: List[str]   =				(1, 153, 370, 371, 1_634, 24_678_051, 115_132_219_018_763_992_565_095_597_973_971_522_401)
a	: Dict   =				(-153, -1, 0, 1.2, 200, "A", [], {}, None)






def        lowerCamelCase__   (					__lowerCamelCase    :  int	):
  if not isinstance(lowercase__						,	lowercase__	) or n < 1:
    return False

  # Initialization of sum and number of digits.
  __UpperCAmelCase							:			List[Any]     =						0
  __UpperCAmelCase							:			List[str]     =						0
  __UpperCAmelCase							:			List[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							:			Optional[int]     =						n
  while temp > 0:
    __UpperCAmelCase							:			Tuple     =						temp % 10
    total += rem**number_of_digits
    temp //= 10
  return n == total






def        lowerCamelCase__   (					__lowerCamelCase    :  int	):
  if not isinstance(lowercase__						,	lowercase__	) or n < 1:
    return False

  # Init a "histogram" of the digits
  __UpperCAmelCase							:			str     =						[0, 0, 0, 0, 0, 0, 0, 0, 0, 0]
  __UpperCAmelCase							:			int     =						0
  __UpperCAmelCase							:			Tuple     =						0
  __UpperCAmelCase							:			Tuple     =						n
  while temp > 0:
    __UpperCAmelCase							:			List[str]     =						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        lowerCamelCase__   (					__lowerCamelCase    :  int	):
  if not isinstance(lowercase__						,	lowercase__	) or n < 1:
    return False
  __UpperCAmelCase							:			int     =						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        lowerCamelCase__   (					):
  __UpperCAmelCase							:			Any     =						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()










class 					a					:



      """simple docstring"""


      def __init__(   self      :    int	,   __lowercase      :    int      )							->   None:
        __UpperCAmelCase							:			str     =						data
        __UpperCAmelCase							:			BinaryTreeNode | None     =						None
        __UpperCAmelCase							:			BinaryTreeNode | None     =						None






def        lowerCamelCase__   (					__lowerCamelCase    :  BinaryTreeNode | None						,	__lowerCamelCase    :  int	):
  if node is None:
    __UpperCAmelCase							:			Optional[int]     =						BinaryTreeNode(__lowerCamelCase	)
    return node

  # binary search tree is not empty,
  # so we will insert it into the tree
  # if new_value is less than value of data in node,
  #  add it to left subtree and proceed recursively
  if new_value < node.data:
    __UpperCAmelCase							:			int     =						insert(node.left_child						,	__lowerCamelCase	)
  else:
    # if new_value is greater than value of data in node,
    #  add it to right subtree and proceed recursively
    __UpperCAmelCase							:			Dict     =						insert(node.right_child						,	__lowerCamelCase	)
  return node






def        lowerCamelCase__   (					__lowerCamelCase    :  None | BinaryTreeNode	):  # if node is None,return
  if node:
    __UpperCAmelCase							:			Optional[Any]     =						inorder(node.left_child	)
    __UpperCAmelCase							:			str     =						[*inorder_array, node.data]
    __UpperCAmelCase							:			Optional[Any]     =						inorder_array + inorder(node.right_child	)
  else:
    __UpperCAmelCase							:			Tuple     =						[]
  return inorder_array






def        lowerCamelCase__   (					):
  __UpperCAmelCase							:			Any     =						insert(__lowerCamelCase						,	15	)
  insert(__lowerCamelCase						,	10	)
  insert(__lowerCamelCase						,	25	)
  insert(__lowerCamelCase						,	6	)
  insert(__lowerCamelCase						,	14	)
  insert(__lowerCamelCase						,	20	)
  insert(__lowerCamelCase						,	60	)
  return root






def        lowerCamelCase__   (					):
  # main function
  __UpperCAmelCase							:			int     =						make_tree()
  print("""Printing values of binary search tree in Inorder Traversal."""	)
  inorder(__lowerCamelCase	)


if __name__ == "__main__":
       import doctest

       doctest.testmod()
       main()


