



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 			UpperCAmelCase__     (     lowercase__ )			->   bool:
						if not isinstance(lowercase__    ,							lowercase__ ) or n < 1:
												return False

						# Initialization of sum and number of digits.
						__lowercase											=					0
						__lowercase											=					0
						__lowercase											=					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
						__lowercase											=					n
						while temp > 0:
												__lowercase											=					temp % 10
												total += rem**number_of_digits
												temp //= 10
						return n == total






def 			UpperCAmelCase__     (     lowercase__ )			->   bool:
						if not isinstance(lowercase__    ,							lowercase__ ) or n < 1:
												return False

						# Init a "histogram" of the digits
						__lowercase											=					[0, 0, 0, 0, 0, 0, 0, 0, 0, 0]
						__lowercase											=					0
						__lowercase											=					0
						__lowercase											=					n
						while temp > 0:
												__lowercase						,      __lowercase											=					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 			UpperCAmelCase__     (     lowercase__ )			->   bool:
						if not isinstance(lowercase__    ,							lowercase__ ) or n < 1:
												return False
						__lowercase											=					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 			UpperCAmelCase__     (     )			->   Dict:
						__lowercase											=					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()










from __future__ import annotations

from typing import Generic, TypeVar

UpperCamelCase__			=    TypeVar("T")
class       _lowerCAmelCase (			Generic[T]      ):






			"""simple docstring"""





			def __init__(					self						:							int      ,  lowercase						:							T )    ->       Union[str, Any]:
									"""simple docstring"""







									__lowercase											=					data  # Assign data
									__lowercase											=					None  # Initialize next as null
									__lowercase											=					None  # Initialize prev as null





class       _lowerCAmelCase (			Generic[T]      ):






			"""simple docstring"""





			def __init__(					self						:							Any )    ->       None:
									"""simple docstring"""







									__lowercase											=					None





			def 		snake_case__      (					self						:							str      ,  lowercase						:							T )    ->       None:
									"""simple docstring"""







									if self.head is None:
															__lowercase											=					Node(lowercase )
									else:
															__lowercase											=					Node(lowercase )
															__lowercase											=					new_node
															__lowercase											=					self.head
															__lowercase											=					None
															__lowercase											=					new_node





			def 		snake_case__      (					self						:							Optional[Any] )    ->       T | None:
									"""simple docstring"""







									if self.head is None:
															return None
									else:
															assert self.head is not None
															__lowercase											=					self.head.data
															__lowercase											=					self.head.next
															if self.head is not None:
																					__lowercase											=					None
															return temp





			def 		snake_case__      (					self						:							Optional[Any] )    ->       T | None:
									"""simple docstring"""







									return self.head.data if self.head is not None else None





			def __len__(					self						:							List[str] )    ->       int:
									"""simple docstring"""







									__lowercase											=					self.head
									__lowercase											=					0
									while temp is not None:
															count += 1
															__lowercase											=					temp.next
									return count





			def 		snake_case__      (					self						:							Optional[Any] )    ->       bool:
									"""simple docstring"""







									return self.head is None







			def 		snake_case__      (					self						:							Optional[Any] )    ->       None:
									"""simple docstring"""







									print("""stack elements are:""" )
									__lowercase											=					self.head
									while temp is not None:
															print(temp.data      ,  end="""->""" )
															__lowercase											=					temp.next


# Code execution starts here
if __name__ == "__main__":
			# Start with the empty stack
			UpperCamelCase__			=    Stack()

			# Insert 4 at the beginning. So stack becomes 4->None
			print("Stack operations using Doubly LinkedList")
			stack.push(4)

			# Insert 5 at the beginning. So stack becomes 4->5->None
			stack.push(5)

			# Insert 6 at the beginning. So stack becomes 4->5->6->None
			stack.push(6)

			# Insert 7 at the beginning. So stack becomes 4->5->6->7->None
			stack.push(7)

			# Print the stack
			stack.print_stack()

			# Print the top element
			print("\nTop element is ", stack.top())

			# Print the stack size
			print("Size of the stack is ", len(stack))

			# pop the top element
			stack.pop()

			# pop the top element
			stack.pop()

			# two elements have now been popped off
			stack.print_stack()

			# Print True if the stack is empty else False
			print("\nstack is empty:", stack.is_empty())





