




'''simple docstring'''







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






def 	_lowercase	(			lowercase_						):



		'''simple docstring'''







		if not isinstance(lowercase_		,							lowercase_						) or n < 1:
				return False

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






def 	_lowercase	(			lowercase_						):



		'''simple docstring'''







		if not isinstance(lowercase_		,							lowercase_						) or n < 1:
				return False

		# Init a "histogram" of the digits
		_snake_case			 = [0, 0, 0, 0, 0, 0, 0, 0, 0, 0]
		_snake_case			 = 0
		_snake_case			 = 0
		_snake_case			 = n
		while temp > 0:
				_snake_case ,					_snake_case			 = 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 	_lowercase	(			lowercase_						):



		'''simple docstring'''







		if not isinstance(lowercase_		,							lowercase_						) or n < 1:
				return False
		_snake_case			 = 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 	_lowercase	(			):



		'''simple docstring'''







		_snake_case			 = 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()











'''simple docstring'''







import json
import os
import unittest

from transformers.models.gpt_neox_japanese.tokenization_gpt_neox_japanese import (
    VOCAB_FILES_NAMES,
    GPTNeoXJapaneseTokenizer,
)
from transformers.testing_utils import require_tokenizers, slow

from ...test_tokenization_common import TokenizerTesterMixin





@require_tokenizers
class   lowerCamelCase_							( UpperCAmelCase_, unittest.TestCase							):




					'''simple docstring'''






					lowercase__					=				GPTNeoXJapaneseTokenizer
					lowercase__					=				False
					lowercase__					=				{"""do_clean_text""": False, """add_prefix_space""": False}






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

							_snake_case			 = [
							    "こん",
							    "こんに",
							    "にちは",
							    "ばんは",
							    "世界,㔺界",
							    "、",
							    "。",
							    "<BR>",
							    "<SP>",
							    "<TAB>",
							    "<URL>",
							    "<EMAIL>",
							    "<TEL>",
							    "<DATE>",
							    "<PRICE>",
							    "<BLOCK>",
							    "<KIGOU>",
							    "<U2000U2BFF>",
							    "<|emoji1|>",
							    "<unk>",
							    "<|startoftext|>",
							    "<|endoftext|>",
							]
							_snake_case			 = {"emoji": {"\ud83d\ude00": "<|emoji1|>"}, "emoji_inv": {"<|emoji1|>": "\ud83d\ude00"}}  # 😀
							_snake_case			 = {"unk_token": "<unk>"}

							_snake_case			 = os.path.join(self.tmpdirname,						VOCAB_FILES_NAMES["vocab_file"]				)
							_snake_case			 = os.path.join(self.tmpdirname,						VOCAB_FILES_NAMES["emoji_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.emoji_file,						"w"				) as emoji_writer:
									emoji_writer.write(json.dumps(__UpperCamelCase				)				)






					def        __SCREAMING_SNAKE_CASE			(					self,						**__UpperCamelCase				):
							kwargs.update(self.special_tokens_map				)
							return GPTNeoXJapaneseTokenizer.from_pretrained(self.tmpdirname,						**__UpperCamelCase				)






					def        __SCREAMING_SNAKE_CASE			(					self,						__UpperCamelCase				):
							_snake_case			 = "こんにちは、世界。 \nこんばんは、㔺界。😀"
							_snake_case			 = "こんにちは、世界。 \nこんばんは、世界。😀"
							return input_text, output_text






					def        __SCREAMING_SNAKE_CASE			(					self,						__UpperCamelCase				):
							_snake_case ,					_snake_case			 = self.get_input_output_texts(__UpperCamelCase				)
							_snake_case			 = tokenizer.encode(__UpperCamelCase,						add_special_tokens=__UpperCamelCase				)
							_snake_case			 = tokenizer.decode(__UpperCamelCase,						clean_up_tokenization_spaces=__UpperCamelCase				)
							return text, ids






					def        __SCREAMING_SNAKE_CASE			(					self				):
							pass  # TODO add if relevant






					def        __SCREAMING_SNAKE_CASE			(					self				):
							pass  # TODO add if relevant






					def        __SCREAMING_SNAKE_CASE			(					self				):
							pass  # TODO add if relevant






					def        __SCREAMING_SNAKE_CASE			(					self				):
							_snake_case			 = self.get_tokenizer()

							# Testing tokenization
							_snake_case			 = "こんにちは、世界。　こんばんは、㔺界。"
							_snake_case			 = ["こん", "にちは", "、", "世界", "。", "<SP>", "こん", "ばんは", "、", "㔺界", "。"]
							_snake_case			 = tokenizer.tokenize(__UpperCamelCase				)
							self.assertListEqual(__UpperCamelCase,						__UpperCamelCase				)

							# Testing conversion to ids without special tokens
							_snake_case			 = [0, 2, 5, 4, 6, 8, 0, 3, 5, 4, 6]
							_snake_case			 = tokenizer.convert_tokens_to_ids(__UpperCamelCase				)
							self.assertListEqual(__UpperCamelCase,						__UpperCamelCase				)

							# Testing conversion to ids with special tokens
							_snake_case			 = tokens + [tokenizer.unk_token]
							_snake_case			 = [0, 2, 5, 4, 6, 8, 0, 3, 5, 4, 6, 19]
							_snake_case			 = tokenizer.convert_tokens_to_ids(__UpperCamelCase				)
							self.assertListEqual(__UpperCamelCase,						__UpperCamelCase				)






					@slow
					def        __SCREAMING_SNAKE_CASE			(					self				):
							_snake_case			 = self.tokenizer_class.from_pretrained("abeja/gpt-neox-japanese-2.7b"				)

							_snake_case			 = tokenizer.encode("ありがとう。",						add_special_tokens=__UpperCamelCase				)
							_snake_case			 = tokenizer.encode("どういたしまして。",						add_special_tokens=__UpperCamelCase				)

							_snake_case			 = tokenizer.build_inputs_with_special_tokens(__UpperCamelCase				)
							_snake_case			 = tokenizer.build_inputs_with_special_tokens(__UpperCamelCase,						__UpperCamelCase				)

							assert encoded_sentence == ids_a
							assert encoded_pair == ids_a + ids_a






					def        __SCREAMING_SNAKE_CASE			(					self				):
							# Intentionally convert some words to accommodate character fluctuations unique to Japanese
							pass






					def        __SCREAMING_SNAKE_CASE			(					self				):
							# tokenizer has no padding token
							pass





