






'''simple docstring'''







import json
import os
import unittest

from transformers.models.roc_bert.tokenization_roc_bert import (
    VOCAB_FILES_NAMES,
    RoCBertBasicTokenizer,
    RoCBertTokenizer,
    RoCBertWordpieceTokenizer,
    _is_control,
    _is_punctuation,
    _is_whitespace,
)
from transformers.testing_utils import require_tokenizers, slow

from ...test_tokenization_common import TokenizerTesterMixin, filter_non_english




@require_tokenizers
class 		UpperCamelCase__    (_UpperCamelCase   ,unittest.TestCase			):




		'''simple docstring'''





		_UpperCamelCase				  =					RoCBertTokenizer
		_UpperCamelCase				  =					None
		_UpperCamelCase				  =					False
		_UpperCamelCase				  =					True
		_UpperCamelCase				  =					filter_non_english






		def 			UpperCamelCase_					(      self       ):
								super().setUp()

								lowerCamelCase__         =  ["[UNK]", "[CLS]", "[SEP]", "[PAD]", "[MASK]", "你", "好", "是", "谁", "a", "b", "c", "d"]
								lowerCamelCase__         =  {}
								lowerCamelCase__         =  {}
								for i, value in enumerate(__a       ):
														lowerCamelCase__         =  i
														lowerCamelCase__         =  i
								lowerCamelCase__         =  os.path.join(self.tmpdirname   ,VOCAB_FILES_NAMES["""vocab_file"""]       )
								lowerCamelCase__         =  os.path.join(self.tmpdirname   ,VOCAB_FILES_NAMES["""word_shape_file"""]       )
								lowerCamelCase__         =  os.path.join(self.tmpdirname   ,VOCAB_FILES_NAMES["""word_pronunciation_file"""]       )
								with open(self.vocab_file   ,"""w"""   ,encoding="""utf-8"""       ) as vocab_writer:
														vocab_writer.write("""""".join([x + """\n""" for x in vocab_tokens]       )       )
								with open(self.word_shape_file   ,"""w"""   ,encoding="""utf-8"""       ) as word_shape_writer:
														json.dump(__a   ,__a   ,ensure_ascii=__a       )
								with open(self.word_pronunciation_file   ,"""w"""   ,encoding="""utf-8"""       ) as word_pronunciation_writer:
														json.dump(__a   ,__a   ,ensure_ascii=__a       )






		def 			UpperCamelCase_					(      self       ):
								lowerCamelCase__         =  self.tokenizer_class(self.vocab_file   ,self.word_shape_file   ,self.word_pronunciation_file       )

								lowerCamelCase__         =  tokenizer.tokenize("""你好[SEP]你是谁"""       )
								self.assertListEqual(__a   ,["""你""", """好""", """[SEP]""", """你""", """是""", """谁"""]       )
								self.assertListEqual(tokenizer.convert_tokens_to_ids(__a       )   ,[5, 6, 2, 5, 7, 8]       )
								self.assertListEqual(tokenizer.convert_tokens_to_shape_ids(__a       )   ,[5, 6, 2, 5, 7, 8]       )
								self.assertListEqual(tokenizer.convert_tokens_to_pronunciation_ids(__a       )   ,[5, 6, 2, 5, 7, 8]       )






		def 			UpperCamelCase_					(      self       ):
								lowerCamelCase__         =  RoCBertBasicTokenizer()

								self.assertListEqual(tokenizer.tokenize("""ah\u535A\u63A8zz"""       )   ,["""ah""", """\u535A""", """\u63A8""", """zz"""]       )






		def 			UpperCamelCase_					(      self       ):
								lowerCamelCase__         =  RoCBertBasicTokenizer(do_lower_case=__a       )

								self.assertListEqual(
								    tokenizer.tokenize(""" \tHeLLo!how  \n Are yoU?  """       )   ,["""hello""", """!""", """how""", """are""", """you""", """?"""]       )
								self.assertListEqual(tokenizer.tokenize("""H\u00E9llo"""       )   ,["""hello"""]       )






		def 			UpperCamelCase_					(      self       ):
								lowerCamelCase__         =  RoCBertBasicTokenizer(do_lower_case=__a   ,strip_accents=__a       )

								self.assertListEqual(
								    tokenizer.tokenize(""" \tHäLLo!how  \n Are yoU?  """       )   ,["""hällo""", """!""", """how""", """are""", """you""", """?"""]       )
								self.assertListEqual(tokenizer.tokenize("""H\u00E9llo"""       )   ,["""h\u00E9llo"""]       )






		def 			UpperCamelCase_					(      self       ):
								lowerCamelCase__         =  RoCBertBasicTokenizer(do_lower_case=__a   ,strip_accents=__a       )

								self.assertListEqual(
								    tokenizer.tokenize(""" \tHäLLo!how  \n Are yoU?  """       )   ,["""hallo""", """!""", """how""", """are""", """you""", """?"""]       )
								self.assertListEqual(tokenizer.tokenize("""H\u00E9llo"""       )   ,["""hello"""]       )






		def 			UpperCamelCase_					(      self       ):
								lowerCamelCase__         =  RoCBertBasicTokenizer(do_lower_case=__a       )

								self.assertListEqual(
								    tokenizer.tokenize(""" \tHäLLo!how  \n Are yoU?  """       )   ,["""hallo""", """!""", """how""", """are""", """you""", """?"""]       )
								self.assertListEqual(tokenizer.tokenize("""H\u00E9llo"""       )   ,["""hello"""]       )






		def 			UpperCamelCase_					(      self       ):
								lowerCamelCase__         =  RoCBertBasicTokenizer(do_lower_case=__a       )

								self.assertListEqual(
								    tokenizer.tokenize(""" \tHeLLo!how  \n Are yoU?  """       )   ,["""HeLLo""", """!""", """how""", """Are""", """yoU""", """?"""]       )






		def 			UpperCamelCase_					(      self       ):
								lowerCamelCase__         =  RoCBertBasicTokenizer(do_lower_case=__a   ,strip_accents=__a       )

								self.assertListEqual(
								    tokenizer.tokenize(""" \tHäLLo!how  \n Are yoU?  """       )   ,["""HäLLo""", """!""", """how""", """Are""", """yoU""", """?"""]       )






		def 			UpperCamelCase_					(      self       ):
								lowerCamelCase__         =  RoCBertBasicTokenizer(do_lower_case=__a   ,strip_accents=__a       )

								self.assertListEqual(
								    tokenizer.tokenize(""" \tHäLLo!how  \n Are yoU?  """       )   ,["""HaLLo""", """!""", """how""", """Are""", """yoU""", """?"""]       )






		def 			UpperCamelCase_					(      self       ):
								lowerCamelCase__         =  RoCBertBasicTokenizer(do_lower_case=__a   ,never_split=["""[UNK]"""]       )

								self.assertListEqual(
								    tokenizer.tokenize(""" \tHeLLo!how  \n Are yoU? [UNK]"""       )   ,["""HeLLo""", """!""", """how""", """Are""", """yoU""", """?""", """[UNK]"""]       )






		def 			UpperCamelCase_					(      self       ):
								lowerCamelCase__         =  ["[UNK]", "[CLS]", "[SEP]", "want", "##want", "##ed", "wa", "un", "runn", "##ing"]

								lowerCamelCase__         =  {}
								for i, token in enumerate(__a       ):
														lowerCamelCase__         =  i
								lowerCamelCase__         =  RoCBertWordpieceTokenizer(vocab=__a   ,unk_token="""[UNK]"""       )

								self.assertListEqual(tokenizer.tokenize(""""""       )   ,[]       )

								self.assertListEqual(tokenizer.tokenize("""unwanted running"""       )   ,["""un""", """##want""", """##ed""", """runn""", """##ing"""]       )

								self.assertListEqual(tokenizer.tokenize("""unwantedX running"""       )   ,["""[UNK]""", """runn""", """##ing"""]       )






		def 			UpperCamelCase_					(      self       ):
								self.assertTrue(_is_whitespace(""" """       )       )
								self.assertTrue(_is_whitespace("""\t"""       )       )
								self.assertTrue(_is_whitespace("""\r"""       )       )
								self.assertTrue(_is_whitespace("""\n"""       )       )
								self.assertTrue(_is_whitespace("""\u00A0"""       )       )

								self.assertFalse(_is_whitespace("""A"""       )       )
								self.assertFalse(_is_whitespace("""-"""       )       )






		def 			UpperCamelCase_					(      self       ):
								self.assertTrue(_is_control("""\u0005"""       )       )

								self.assertFalse(_is_control("""A"""       )       )
								self.assertFalse(_is_control(""" """       )       )
								self.assertFalse(_is_control("""\t"""       )       )
								self.assertFalse(_is_control("""\r"""       )       )






		def 			UpperCamelCase_					(      self       ):
								self.assertTrue(_is_punctuation("""-"""       )       )
								self.assertTrue(_is_punctuation("""$"""       )       )
								self.assertTrue(_is_punctuation("""`"""       )       )
								self.assertTrue(_is_punctuation("""."""       )       )

								self.assertFalse(_is_punctuation("""A"""       )       )
								self.assertFalse(_is_punctuation(""" """       )       )






		def 			UpperCamelCase_					(      self       ):
								lowerCamelCase__         =  self.get_tokenizer()

								# Example taken from the issue https://github.com/huggingface/tokenizers/issues/340
								self.assertListEqual([tokenizer.tokenize(__a       ) for t in ["""Test""", """\xad""", """test"""]]   ,[["""[UNK]"""], [], ["""[UNK]"""]]       )

								if self.test_rust_tokenizer:
														lowerCamelCase__         =  self.get_rust_tokenizer()
														self.assertListEqual(
														    [rust_tokenizer.tokenize(__a       ) for t in ["""Test""", """\xad""", """test"""]]   ,[["""[UNK]"""], [], ["""[UNK]"""]]       )






		def 			UpperCamelCase_					(      self       ):
								for tokenizer, pretrained_name, kwargs in self.tokenizers_list:
														with self.subTest(F'''{tokenizer.__class__.__name__} ({pretrained_name})'''       ):
																				lowerCamelCase__         =  self.rust_tokenizer_class.from_pretrained(__a   ,**__a       )

																				lowerCamelCase__         =  F'''A, naïve {tokenizer_r.mask_token} AllenNLP sentence.'''
																				lowerCamelCase__         =  tokenizer_r.encode_plus(
																				    __a   ,return_attention_mask=__a   ,return_token_type_ids=__a   ,return_offsets_mapping=__a   ,add_special_tokens=__a   ,)

																				lowerCamelCase__         =  tokenizer_r.do_lower_case if hasattr(__a   ,"""do_lower_case"""       ) else False
																				lowerCamelCase__         =  (
																				    [
																				        ((0, 0), tokenizer_r.cls_token),
																				        ((0, 1), "A"),
																				        ((1, 2), ","),
																				        ((3, 5), "na"),
																				        ((5, 6), "##ï"),
																				        ((6, 8), "##ve"),
																				        ((9, 15), tokenizer_r.mask_token),
																				        ((16, 21), "Allen"),
																				        ((21, 23), "##NL"),
																				        ((23, 24), "##P"),
																				        ((25, 33), "sentence"),
																				        ((33, 34), "."),
																				        ((0, 0), tokenizer_r.sep_token),
																				    ]
																				    if not do_lower_case
																				    else [
																				        ((0, 0), tokenizer_r.cls_token),
																				        ((0, 1), "a"),
																				        ((1, 2), ","),
																				        ((3, 8), "naive"),
																				        ((9, 15), tokenizer_r.mask_token),
																				        ((16, 21), "allen"),
																				        ((21, 23), "##nl"),
																				        ((23, 24), "##p"),
																				        ((25, 33), "sentence"),
																				        ((33, 34), "."),
																				        ((0, 0), tokenizer_r.sep_token),
																				    ]
																				)

																				self.assertEqual(
																				    [e[1] for e in expected_results]   ,tokenizer_r.convert_ids_to_tokens(tokens["""input_ids"""]       )       )
																				self.assertEqual([e[0] for e in expected_results]   ,tokens["""offset_mapping"""]       )






		def 			UpperCamelCase_					(      self       ):
								lowerCamelCase__         =  ["的", "人", "有"]
								lowerCamelCase__         =  "".join(__a       )
								for tokenizer, pretrained_name, kwargs in self.tokenizers_list:
														with self.subTest(F'''{tokenizer.__class__.__name__} ({pretrained_name})'''       ):
																				lowerCamelCase__         =  True
																				lowerCamelCase__         =  self.tokenizer_class.from_pretrained(__a   ,**__a       )
																				lowerCamelCase__         =  self.rust_tokenizer_class.from_pretrained(__a   ,**__a       )

																				lowerCamelCase__         =  tokenizer_p.encode(__a   ,add_special_tokens=__a       )
																				lowerCamelCase__         =  tokenizer_r.encode(__a   ,add_special_tokens=__a       )

																				lowerCamelCase__         =  tokenizer_r.convert_ids_to_tokens(__a       )
																				lowerCamelCase__         =  tokenizer_p.convert_ids_to_tokens(__a       )

																				# it is expected that each Chinese character is not preceded by "##"
																				self.assertListEqual(__a   ,__a       )
																				self.assertListEqual(__a   ,__a       )

																				lowerCamelCase__         =  False
																				lowerCamelCase__         =  self.rust_tokenizer_class.from_pretrained(__a   ,**__a       )
																				lowerCamelCase__         =  self.tokenizer_class.from_pretrained(__a   ,**__a       )

																				lowerCamelCase__         =  tokenizer_r.encode(__a   ,add_special_tokens=__a       )
																				lowerCamelCase__         =  tokenizer_p.encode(__a   ,add_special_tokens=__a       )

																				lowerCamelCase__         =  tokenizer_r.convert_ids_to_tokens(__a       )
																				lowerCamelCase__         =  tokenizer_p.convert_ids_to_tokens(__a       )

																				# it is expected that only the first Chinese character is not preceded by "##".
																				lowerCamelCase__         =  [
																				    F'''##{token}''' if idx != 0 else token for idx, token in enumerate(__a       )
																				]
																				self.assertListEqual(__a   ,__a       )
																				self.assertListEqual(__a   ,__a       )






		@slow
		def 			UpperCamelCase_					(      self       ):
								lowerCamelCase__         =  self.tokenizer_class(self.vocab_file   ,self.word_shape_file   ,self.word_pronunciation_file       )

								lowerCamelCase__         =  tokenizer.encode("""你好"""   ,add_special_tokens=__a       )
								lowerCamelCase__         =  tokenizer.encode("""你是谁"""   ,add_special_tokens=__a       )

								lowerCamelCase__         =  tokenizer.build_inputs_with_special_tokens(__a       )
								lowerCamelCase__         =  tokenizer.build_inputs_with_special_tokens(__a   ,__a       )

								assert encoded_sentence == [1] + text + [2]
								assert encoded_pair == [1] + text + [2] + text_a + [2]






		def 			UpperCamelCase_					(      self       ):
								lowerCamelCase__         =  self.get_tokenizers(do_lower_case=__a       )
								for tokenizer in tokenizers:
														with self.subTest(F'''{tokenizer.__class__.__name__}'''       ):
																				lowerCamelCase__         =  "你好，你是谁"
																				lowerCamelCase__         =  tokenizer.tokenize(__a       )
																				lowerCamelCase__         =  tokenizer.convert_tokens_to_ids(__a       )
																				lowerCamelCase__         =  tokenizer.convert_tokens_to_shape_ids(__a       )
																				lowerCamelCase__         =  tokenizer.convert_tokens_to_pronunciation_ids(__a       )
																				lowerCamelCase__         =  tokenizer.prepare_for_model(
																				    __a   ,__a   ,__a   ,add_special_tokens=__a       )

																				lowerCamelCase__         =  tokenizer.encode_plus(__a   ,add_special_tokens=__a       )

																				self.assertEqual(__a   ,__a       )









'''simple docstring'''







from math import factorial

UpperCamelCase    :      dict[str, int]  			=		{str(digit): factorial(digit) for digit in range(10)}
def 						A__			(				__lowerCAmelCase		:			int						):
						if not isinstance(__lowerCAmelCase   ,    __lowerCAmelCase						):
												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(__lowerCAmelCase						)						)
def 						A__			(				__lowerCAmelCase		:			int = 60   ,    __lowerCAmelCase		:			int = 100_0000						):

						if not isinstance(__lowerCAmelCase   ,    __lowerCAmelCase						) or not isinstance(__lowerCAmelCase   ,    __lowerCAmelCase						):
												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
						lowerCamelCase__         =  0
						# the cached sizes of the previous chains
						lowerCamelCase__         =  {}

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

												# Stop computing the chain when you find a cached size, a repeating item or the
												# length is greater then the desired one.
												lowerCamelCase__         =  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(__lowerCAmelCase						)
																		chain_set_length += 1
																		lowerCamelCase__         =  digit_factorial_sum(__lowerCAmelCase						)

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

												lowerCamelCase__         =  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()}')

