




'''simple docstring'''







from __future__ import annotations

from scipy.special import comb  # type: ignore


class 			_a  :
       def __init__(	self						:	Tuple   ,				lowercase						:	list[tuple[float, float]]				):



           '''simple docstring'''

           UpperCAmelCase			       =		list_of_points
           # Degree determines the flexibility of the curve.
           # Degree = 1 will produce a straight line.
           UpperCAmelCase			       =		len(lowercase_				) - 1
       def     A      (	self						:	Dict   ,				lowercase						:	float				):



           '''simple docstring'''

           assert 0 <= t <= 1, "Time t must be between 0 and 1."
           UpperCAmelCase			       =		[]
           for i in range(len(self.list_of_points				)				):
               # basis function for each i
               output_values.append(
                   comb(self.degree   ,				lowercase_				) * ((1 - t) ** (self.degree - i)) * (t**i)				)
           # the basis must sum up to 1 for it to produce a valid Bezier curve.
           assert round(sum(lowercase_				)   ,				5				) == 1
           return output_values
       def     A      (	self						:	Union[str, Any]   ,				lowercase						:	float				):



           '''simple docstring'''

           assert 0 <= t <= 1, "Time t must be between 0 and 1."

           UpperCAmelCase			       =		self.basis_function(lowercase_				)
           UpperCAmelCase			       =		0.0
           UpperCAmelCase			       =		0.0
           for i in range(len(self.list_of_points				)				):
               # For all points, sum up the product of i-th basis function and i-th point.
               x += basis_function[i] * self.list_of_points[i][0]
               y += basis_function[i] * self.list_of_points[i][1]
           return (x, y)







       def     A      (	self						:	Dict   ,				lowercase						:	float = 0.01				):



           '''simple docstring'''

           from matplotlib import pyplot as plt  # type: ignore

           UpperCAmelCase			       =		[]  # x coordinates of points to plot
           UpperCAmelCase			       =		[]  # y coordinates of points to plot

           UpperCAmelCase			       =		0.0
           while t <= 1:
               UpperCAmelCase			       =		self.bezier_curve_function(lowercase_				)
               to_plot_x.append(value[0]				)
               to_plot_y.append(value[1]				)
               t += step_size

           UpperCAmelCase			       =		[i[0] for i in self.list_of_points]
           UpperCAmelCase			       =		[i[1] for i in self.list_of_points]

           plt.plot(
               lowercase_   ,				lowercase_   ,				color='''blue'''   ,				label='''Curve of Degree ''' + str(self.degree				)   ,				)
           plt.scatter(lowercase_   ,				lowercase_   ,				color='''red'''   ,				label='''Control Points'''				)
           plt.legend()
           plt.show()


if __name__ == "__main__":
   import doctest

   doctest.testmod()

   BezierCurve([(1, 2), (3, 5)]).plot_curve()  # degree 1
   BezierCurve([(0, 0), (5, 5), (5, 0)]).plot_curve()  # degree 2
   BezierCurve([(0, 0), (5, 5), (5, 0), (2.5, -2.5)]).plot_curve()  # degree 3







import os

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





    '''simple docstring'''






    A__          =   os.path.dirname(os.path.realpath(SCREAMING_SNAKE_CASE__      )      )
    A__          =   os.path.join(SCREAMING_SNAKE_CASE__    ,			'words.txt'      )

    A__          =   ''
    with open(SCREAMING_SNAKE_CASE__      ) as f:
        A__          =   f.readline()

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


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

