





'''simple docstring'''

import os

# Precomputes a list of the 100 first triangular numbers
__lowerCAmelCase							:	int			=[int(0.5 * n * (n + 1)) for n in range(1, 101)]





def 						UpperCamelCase				(							):
    A__				=			os.path.dirname(os.path.realpath(_lowerCamelCase       )       )
    A__				=			os.path.join(_lowerCamelCase						,       "words.txt"       )

    A__				=			""
    with open(_lowerCamelCase       ) as f:
        A__				=			f.readline()

    A__				=			[word.strip("\""       ) for word in words.strip("\r\n"       ).split(","       )]
    A__				=			[
        word
        for word in [sum(ord(_lowerCamelCase       ) - 64 for x in word       ) for word in words]
        if word in TRIANGULAR_NUMBERS
    ]
    return len(_lowerCamelCase       )


if __name__ == "__main__":
  print(solution())










'''simple docstring'''

import json
import os
import shutil
import tempfile
import unittest

import numpy as np
import pytest

from transformers import CLIPTokenizer, CLIPTokenizerFast
from transformers.models.clip.tokenization_clip import VOCAB_FILES_NAMES
from transformers.testing_utils import require_vision
from transformers.utils import IMAGE_PROCESSOR_NAME, is_vision_available


if is_vision_available():
  from PIL import Image

  from transformers import CLIPImageProcessor, CLIPProcessor






@require_vision
class    UpperCAmelCase	(       unittest.TestCase				):
 def      UpperCAmelCase_							(				self      :Optional[Any]							)->							Tuple:
     A__				=			tempfile.mkdtemp()

     # fmt: off
     A__				=			["l", "o", "w", "e", "r", "s", "t", "i", "d", "n", "lo", "l</w>", "w</w>", "r</w>", "t</w>", "low</w>", "er</w>", "lowest</w>", "newer</w>", "wider", "<unk>", "<|startoftext|>", "<|endoftext|>"]
     # fmt: on
     A__				=			dict(zip(lowercase_						,       range(len(lowercase_							)							)							)							)
     A__				=			["#version: 0.2", "l o", "lo w</w>", "e r</w>", ""]
     A__				=			{"unk_token": "<unk>"}

     A__				=			os.path.join(self.tmpdirname						,       VOCAB_FILES_NAMES["vocab_file"]							)
     A__				=			os.path.join(self.tmpdirname						,       VOCAB_FILES_NAMES["merges_file"]							)
     with open(self.vocab_file						,       "w"						,       encoding="utf-8"							) as fp:
         fp.write(json.dumps(lowercase_							) + "\n"							)
     with open(self.merges_file						,       "w"						,       encoding="utf-8"							) as fp:
         fp.write("\n".join(lowercase_							)							)

     A__				=			{
         "do_resize": True,
         "size": 20,
         "do_center_crop": True,
         "crop_size": 18,
         "do_normalize": True,
         "image_mean": [0.4_8_1_4_5_4_6_6, 0.4_5_7_8_2_7_5, 0.4_0_8_2_1_0_7_3],
         "image_std": [0.2_6_8_6_2_9_5_4, 0.2_6_1_3_0_2_5_8, 0.2_7_5_7_7_7_1_1],
     }
     A__				=			os.path.join(self.tmpdirname						,       lowercase_							)
     with open(self.image_processor_file						,       "w"						,       encoding="utf-8"							) as fp:
         json.dump(lowercase_						,       lowercase_							)
 def      UpperCAmelCase_							(				self      :Any						,       **lowercase_      :Union[str, Any]							)->							Tuple:
     return CLIPTokenizer.from_pretrained(self.tmpdirname						,       **lowercase_							)
 def      UpperCAmelCase_							(				self      :Any						,       **lowercase_      :Tuple							)->							Dict:
     return CLIPTokenizerFast.from_pretrained(self.tmpdirname						,       **lowercase_							)
 def      UpperCAmelCase_							(				self      :Dict						,       **lowercase_      :Union[str, Any]							)->							Any:
     return CLIPImageProcessor.from_pretrained(self.tmpdirname						,       **lowercase_							)
 def      UpperCAmelCase_							(				self      :List[str]							)->							int:
     shutil.rmtree(self.tmpdirname							)
 def      UpperCAmelCase_							(				self      :Optional[int]							)->							Optional[int]:
     A__				=			[np.random.randint(2_55						,       size=(3, 30, 4_00)						,       dtype=np.uinta							)]

     A__				=			[Image.fromarray(np.moveaxis(lowercase_						,       0						,       -1							)							) for x in image_inputs]

     return image_inputs
 def      UpperCAmelCase_							(				self      :int							)->							List[Any]:
     A__				=			self.get_tokenizer()
     A__				=			self.get_rust_tokenizer()
     A__				=			self.get_image_processor()

     A__				=			CLIPProcessor(tokenizer=lowercase_						,       image_processor=lowercase_							)
     processor_slow.save_pretrained(self.tmpdirname							)
     A__				=			CLIPProcessor.from_pretrained(self.tmpdirname						,       use_fast=lowercase_							)

     A__				=			CLIPProcessor(tokenizer=lowercase_						,       image_processor=lowercase_							)
     processor_fast.save_pretrained(self.tmpdirname							)
     A__				=			CLIPProcessor.from_pretrained(self.tmpdirname							)

     self.assertEqual(processor_slow.tokenizer.get_vocab()						,       tokenizer_slow.get_vocab()							)
     self.assertEqual(processor_fast.tokenizer.get_vocab()						,       tokenizer_fast.get_vocab()							)
     self.assertEqual(tokenizer_slow.get_vocab()						,       tokenizer_fast.get_vocab()							)
     self.assertIsInstance(processor_slow.tokenizer						,       lowercase_							)
     self.assertIsInstance(processor_fast.tokenizer						,       lowercase_							)

     self.assertEqual(processor_slow.image_processor.to_json_string()						,       image_processor.to_json_string()							)
     self.assertEqual(processor_fast.image_processor.to_json_string()						,       image_processor.to_json_string()							)
     self.assertIsInstance(processor_slow.image_processor						,       lowercase_							)
     self.assertIsInstance(processor_fast.image_processor						,       lowercase_							)
 def      UpperCAmelCase_							(				self      :Optional[Any]							)->							Optional[int]:
     A__				=			CLIPProcessor(tokenizer=self.get_tokenizer()						,       image_processor=self.get_image_processor()							)
     processor.save_pretrained(self.tmpdirname							)

     A__				=			self.get_tokenizer(bos_token="(BOS)"						,       eos_token="(EOS)"							)
     A__				=			self.get_image_processor(do_normalize=lowercase_						,       padding_value=1.0							)

     A__				=			CLIPProcessor.from_pretrained(
         self.tmpdirname						,       bos_token="(BOS)"						,       eos_token="(EOS)"						,       do_normalize=lowercase_						,       padding_value=1.0							)

     self.assertEqual(processor.tokenizer.get_vocab()						,       tokenizer_add_kwargs.get_vocab()							)
     self.assertIsInstance(processor.tokenizer						,       lowercase_							)

     self.assertEqual(processor.image_processor.to_json_string()						,       image_processor_add_kwargs.to_json_string()							)
     self.assertIsInstance(processor.image_processor						,       lowercase_							)
 def      UpperCAmelCase_							(				self      :List[Any]							)->							Tuple:
     A__				=			self.get_image_processor()
     A__				=			self.get_tokenizer()

     A__				=			CLIPProcessor(tokenizer=lowercase_						,       image_processor=lowercase_							)

     A__				=			self.prepare_image_inputs()

     A__				=			image_processor(lowercase_						,       return_tensors="np"							)
     A__				=			processor(images=lowercase_						,       return_tensors="np"							)

     for key in input_image_proc.keys():
         self.assertAlmostEqual(input_image_proc[key].sum()						,       input_processor[key].sum()						,       delta=1E-2							)
 def      UpperCAmelCase_							(				self      :Optional[int]							)->							Dict:
     A__				=			self.get_image_processor()
     A__				=			self.get_tokenizer()

     A__				=			CLIPProcessor(tokenizer=lowercase_						,       image_processor=lowercase_							)

     A__				=			"lower newer"

     A__				=			processor(text=lowercase_							)

     A__				=			tokenizer(lowercase_							)

     for key in encoded_tok.keys():
         self.assertListEqual(encoded_tok[key]						,       encoded_processor[key]							)
 def      UpperCAmelCase_							(				self      :str							)->							Any:
     A__				=			self.get_image_processor()
     A__				=			self.get_tokenizer()

     A__				=			CLIPProcessor(tokenizer=lowercase_						,       image_processor=lowercase_							)

     A__				=			"lower newer"
     A__				=			self.prepare_image_inputs()

     A__				=			processor(text=lowercase_						,       images=lowercase_							)

     self.assertListEqual(list(inputs.keys()							)						,       ["input_ids", "attention_mask", "pixel_values"]							)

     # test if it raises when no input is passed
     with pytest.raises(lowercase_							):
         processor()
 def      UpperCAmelCase_							(				self      :Tuple							)->							Tuple:
     A__				=			self.get_image_processor()
     A__				=			self.get_tokenizer()

     A__				=			CLIPProcessor(tokenizer=lowercase_						,       image_processor=lowercase_							)

     A__				=			[[1, 4, 5, 8, 1, 0, 8], [3, 4, 3, 1, 1, 8, 9]]

     A__				=			processor.batch_decode(lowercase_							)
     A__				=			tokenizer.batch_decode(lowercase_							)

     self.assertListEqual(lowercase_						,       lowercase_							)



 def      UpperCAmelCase_							(				self      :List[Any]							)->							Dict:
     A__				=			self.get_image_processor()
     A__				=			self.get_tokenizer()

     A__				=			CLIPProcessor(tokenizer=lowercase_						,       image_processor=lowercase_							)

     A__				=			"lower newer"
     A__				=			self.prepare_image_inputs()

     A__				=			processor(text=lowercase_						,       images=lowercase_							)

     self.assertListEqual(list(inputs.keys()							)						,       processor.model_input_names							)



