






from math import factorial

UpperCAmelCase__							  =						{str(digit): factorial(digit) for digit in range(10)}
def 		_a       ( a					:int					)				->     int:
 if not isinstance(a      ,				a					):
  raise TypeError('''Parameter number must be int'''					)

 if number < 0:
  raise ValueError('''Parameter number must be greater than or equal to 0'''					)

 # Converts number in string to iterate on its digits and adds its factorial.
 return sum(DIGIT_FACTORIAL[digit] for digit in str(a					)					)
def 		_a       ( a					:int = 60      ,				a					:int = 1_000_000					)				->     int:

 if not isinstance(a      ,				a					) or not isinstance(a      ,				a					):
  raise TypeError('''Parameters chain_length and number_limit must be int'''					)

 if chain_length <= 0 or number_limit <= 0:
  raise ValueError(
      '''Parameters chain_length and number_limit must be greater than 0'''					)

 # the counter for the chains with the exact desired length
 a						    = 0
 # the cached sizes of the previous chains
 a						    = {}

 for start_chain_element in range(1      ,				a					):
  # The temporary set will contain the elements of the chain
  a						    = set()
  a						    = 0

  # Stop computing the chain when you find a cached size, a repeating item or the
  # length is greater then the desired one.
  a						    = start_chain_element
  while (
      chain_element not in chain_sets_lengths
      and chain_element not in chain_set
      and chain_set_length <= chain_length
  ):
   chain_set.add(a					)
   chain_set_length += 1
   a						    = digit_factorial_sum(a					)

  if chain_element in chain_sets_lengths:
   chain_set_length += chain_sets_lengths[chain_element]

  a						    = chain_set_length

  # If chain contains the exact amount of elements increase the counter
  if chain_set_length == chain_length:
   chains_counter += 1

 return chains_counter


if __name__ == "__main__":
     import doctest

     doctest.testmod()
     print(f"""{solution()}""")










from typing import Any

import numpy as np
def 		_a       ( a					:np.ndarray					)				->     bool:
 return np.array_equal(a      ,				matrix.conjugate().T					)
def 		_a       ( a					:np.ndarray      ,				a					:np.ndarray					)				->     Any:
 a						    = v.conjugate().T
 a						    = v_star.dot(a					)
 assert isinstance(a      ,				np.ndarray					)
 return (v_star_dot.dot(a					)) / (v_star.dot(a					))
def 		_a       ( )				->     None:
 a						    = np.array([[2, 2 + 1j, 4], [2 - 1j, 3, 1j], [4, -1j, 1]]					)
 a						    = np.array([[1], [2], [3]]					)
 assert is_hermitian(a					), F"""{a} is not hermitian."""
 print(rayleigh_quotient(a      ,				a					)					)

 a						    = np.array([[1, 2, 4], [2, 3, -1], [4, -1, 1]]					)
 assert is_hermitian(a					), F"""{a} is not hermitian."""
 assert rayleigh_quotient(a      ,				a					) == float(3					)


if __name__ == "__main__":
     import doctest

     doctest.testmod()
     tests()


