from __future__ import annotations

from scipy.special import comb  # type: ignore





class 				_A		:

      def __init__(		self	, __lowerCAmelCase		):







            """simple docstring"""



            lowercase														=			list_of_points
            # Degree determines the flexibility of the curve.
            # Degree = 1 will produce a straight line.
            lowercase														=			len(__lowerCAmelCase		) - 1

      def        A__ (		self	, __lowerCAmelCase		):







            """simple docstring"""



            assert 0 <= t <= 1, "Time t must be between 0 and 1."
            lowercase														=			[]
            for i in range(len(self.list_of_points		)		):
                  # basis function for each i
                  output_values.append(
                      comb(self.degree	, __lowerCAmelCase		) * ((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(__lowerCAmelCase		)	, 5		) == 1
            return output_values

      def        A__ (		self	, __lowerCAmelCase		):







            """simple docstring"""



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

            lowercase														=			self.basis_function(__lowerCAmelCase		)
            lowercase														=			0.0
            lowercase														=			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	, __lowerCAmelCase = 0.0_1		):







            """simple docstring"""



            from matplotlib import pyplot as plt  # type: ignore

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

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

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

            plt.plot(
                __lowerCAmelCase	, __lowerCAmelCase	, color="""blue"""	, label="""Curve of Degree """ + str(self.degree		)	, )
            plt.scatter(__lowerCAmelCase	, __lowerCAmelCase	, 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




"""simple docstring"""






from __future__ import annotations


def     UpperCAmelCase__ (       lowerCAmelCase__  :list[float]      ,	lowerCAmelCase__  :list[float]	)				->					float:
      '''simple docstring'''


      lowercase														=			sorted(numsa + numsa	)
      lowercase							,							lowercase														=			divmod(len(lowerCAmelCase__	)      ,	2	)
      if mod == 1:
            return all_numbers[div]
      else:
            return (all_numbers[div] + all_numbers[div - 1]) / 2


if __name__ == "__main__":
       import doctest

       doctest.testmod()
       __lowerCAmelCase					: List[Any]        =[float(x) for x in input("""Enter the elements of first array: """).split()]
       __lowerCAmelCase					: List[Any]        =[float(x) for x in input("""Enter the elements of second array: """).split()]
       print(F"""The median of two arrays is: {median_of_two_arrays(array_a, array_a)}""")



