


def __UpperCAmelCase       (		__A = 1_0 ,						__A = 2_2			)						->					int:



       '''simple docstring'''





       UpperCAmelCase__										=     range(1 ,						__A			)
       UpperCAmelCase__										=     range(1 ,						__A			)
       return sum(
           1 for power in powers for base in bases if len(str(base**power			)			) == power			)


if __name__ == "__main__":
    print(f"{solution(10, 22) = }")









import os
import unittest

from transformers.models.bartpho.tokenization_bartpho import VOCAB_FILES_NAMES, BartphoTokenizer
from transformers.testing_utils import get_tests_dir

from ...test_tokenization_common import TokenizerTesterMixin


A      = get_tests_dir("fixtures/test_sentencepiece_bpe.model")


class     lowercase__  (					__SCREAMING_SNAKE_CASE					,							unittest.TestCase		):
  A__=  BartphoTokenizer
  A__=  False
  A__=  True






  def 			_UpperCAmelCase  (					self      :					Dict ):




         """simple docstring"""







         super().setUp()

         UpperCAmelCase__										=     ["▁This", "▁is", "▁a", "▁t", "est"]
         UpperCAmelCase__										=     dict(zip(_lowercase		,						range(len(_lowercase ) ) ) )
         UpperCAmelCase__										=     {"unk_token": "<unk>"}

         UpperCAmelCase__										=     os.path.join(self.tmpdirname		,						VOCAB_FILES_NAMES["monolingual_vocab_file"] )
         with open(self.monolingual_vocab_file		,						"w"		,						encoding="utf-8" ) as fp:
                for token in vocab_tokens:
                       fp.write(F"""{token} {vocab_tokens[token]}\n""" )

         UpperCAmelCase__										=     BartphoTokenizer(_lowercase		,						self.monolingual_vocab_file		,						**self.special_tokens_map )
         tokenizer.save_pretrained(self.tmpdirname )






  def 			_UpperCAmelCase  (					self      :					Dict		,						**_lowercase      :					Optional[Any] ):




         """simple docstring"""







         kwargs.update(self.special_tokens_map )
         return BartphoTokenizer.from_pretrained(self.tmpdirname		,						**_lowercase )






  def 			_UpperCAmelCase  (					self      :					List[Any]		,						_lowercase      :					Union[str, Any] ):




         """simple docstring"""







         UpperCAmelCase__										=     "This is a là test"
         UpperCAmelCase__										=     "This is a<unk><unk> test"
         return input_text, output_text






  def 			_UpperCAmelCase  (					self      :					Optional[Any] ):




         """simple docstring"""







         UpperCAmelCase__										=     BartphoTokenizer(_lowercase		,						self.monolingual_vocab_file		,						**self.special_tokens_map )
         UpperCAmelCase__										=     "This is a là test"
         UpperCAmelCase__										=     "▁This ▁is ▁a ▁l à ▁t est".split()
         UpperCAmelCase__										=     tokenizer.tokenize(_lowercase )
         self.assertListEqual(_lowercase		,						_lowercase )

         UpperCAmelCase__										=     tokens + [tokenizer.unk_token]
         UpperCAmelCase__										=     [4, 5, 6, 3, 3, 7, 8, 3]
         self.assertListEqual(tokenizer.convert_tokens_to_ids(_lowercase )		,						_lowercase )





