'''simple docstring'''




from __future__ import annotations

from scipy.special import comb  # type: ignore




class    a__				:






     def __init__(			self		:		Optional[Any]  ,    a		:		List[str]   ):





        """simple docstring"""



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






     def        SCREAMING_SNAKE_CASE__       (			self		:		Tuple  ,    a		:		Union[str, Any]   ):





        """simple docstring"""



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






     def        SCREAMING_SNAKE_CASE__       (			self		:		Union[str, Any]  ,    a		:		Tuple   ):





        """simple docstring"""



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

        __lowerCamelCase          =  self.basis_function(_SCREAMING_SNAKE_CASE   )
        __lowerCamelCase          =  0.0
        __lowerCamelCase          =  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        SCREAMING_SNAKE_CASE__       (			self		:		List[Any]  ,    a		:		Optional[int] = 0.01   ):





        """simple docstring"""



        from matplotlib import pyplot as plt  # type: ignore

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

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

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

        plt.plot(
            _SCREAMING_SNAKE_CASE  ,    _SCREAMING_SNAKE_CASE  ,    color='''blue'''  ,    label='''Curve of Degree ''' + str(self.degree   )  ,    )
        plt.scatter(_SCREAMING_SNAKE_CASE  ,    _SCREAMING_SNAKE_CASE  ,    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 __lowerCAmelCase			(							UpperCamelCase__    ,  UpperCamelCase__    )     ->   list[list[int]]:
    __lowerCamelCase          =  []
    create_all_state(1    ,  UpperCamelCase__    ,  UpperCamelCase__    ,  []    ,  UpperCamelCase__    )
    return result






def __lowerCAmelCase			(							UpperCamelCase__    ,  UpperCamelCase__    ,  UpperCamelCase__    ,  UpperCamelCase__    ,  UpperCamelCase__    ,  )     ->   None:
    if level == 0:
        total_list.append(current_list[:]    )
        return

    for i in range(UpperCamelCase__    ,  total_number - level + 2    ):
        current_list.append(UpperCamelCase__    )
        create_all_state(i + 1    ,  UpperCamelCase__    ,  level - 1    ,  UpperCamelCase__    ,  UpperCamelCase__    )
        current_list.pop()






def __lowerCAmelCase			(							UpperCamelCase__    )     ->   None:
    for i in total_list:
        print(*UpperCamelCase__    )


if __name__ == "__main__":
  __UpperCAmelCase												=4
  __UpperCAmelCase												=2
  __UpperCAmelCase												=generate_all_combinations(n, k)
  print_all_state(total_list)
