


def 							SCREAMING_SNAKE_CASE					(  _UpperCAmelCase				)    ->  str:
						if len(_UpperCAmelCase				) == 0 or not all(len(_UpperCAmelCase				) == 2 for pair in coordinates				):
												raise ValueError('The program cannot work out a fitting polynomial.'				)

						if len({tuple(_UpperCAmelCase				) for pair in coordinates}				) != len(_UpperCAmelCase				):
												raise ValueError('The program cannot work out a fitting polynomial.'				)

						_a     =			{x for x, _ in coordinates}
						if len(_UpperCAmelCase				) == 1:
												return f"""x={coordinates[0][0]}"""

						if len(_UpperCAmelCase				) != len(_UpperCAmelCase				):
												raise ValueError('The program cannot work out a fitting polynomial.'				)

						_a     =			len(_UpperCAmelCase				)

						_a     =			0
						_a     =			[]
						# put the x and x to the power values in a matrix
						while count_of_line < x:
												_a     =			0
												_a     =			coordinates[count_of_line][0]
												_a     =			[]
												while count_in_line < x:
																		count_line.append(a ** (x - (count_in_line + 1))				)
																		count_in_line += 1
												matrix.append(_UpperCAmelCase				)
												count_of_line += 1

						_a     =			0
						# put the y values into a vector
						_a     =			[]
						while count_of_line < x:
												vector.append(coordinates[count_of_line][1]				)
												count_of_line += 1

						_a     =			0

						while count < x:
												_a     =			0
												while zahlen < x:
																		if count == zahlen:
																								zahlen += 1
																		if zahlen == x:
																								break
																		_a     =			matrix[zahlen][count] / matrix[count][count]
																		for counting_columns, item in enumerate(matrix[count]				):
																								# manipulating all the values in the matrix
																								matrix[zahlen][counting_columns] -= item * bruch
																		# manipulating the values in the vector
																		vector[zahlen] -= vector[count] * bruch
																		zahlen += 1
												count += 1

						_a     =			0
						# make solutions
						_a     =			[]
						while count < x:
												solution.append(str(vector[count] / matrix[count][count]				)				)
												count += 1

						_a     =			0
						_a     =			'f(x)='

						while count < x:
												_a     =			solution[count].split('E'				)
												if len(_UpperCAmelCase				) > 1:
																		_a     =			f"""{remove_e[0]}*10^{remove_e[1]}"""
												solved += f"""x^{x - (count + 1)}*{solution[count]}"""
												if count + 1 != x:
																		solved += "+"
												count += 1

						return solved


if __name__ == "__main__":
		print(points_to_polynomial([]))
		print(points_to_polynomial([[]]))
		print(points_to_polynomial([[1, 0], [2, 0], [3, 0]]))
		print(points_to_polynomial([[1, 1], [2, 1], [3, 1]]))
		print(points_to_polynomial([[1, 3], [2, 3], [3, 3]]))
		print(points_to_polynomial([[1, 1], [2, 2], [3, 3]]))
		print(points_to_polynomial([[1, 1], [2, 4], [3, 9]]))
		print(points_to_polynomial([[1, 3], [2, 6], [3, 11]]))
		print(points_to_polynomial([[1, -3], [2, -6], [3, -11]]))
		print(points_to_polynomial([[1, 5], [2, 2], [3, 9]]))






from math import pi


def 							SCREAMING_SNAKE_CASE					(  _UpperCAmelCase				)    ->  float:
						return degree / (180 / pi)


if __name__ == "__main__":
		from doctest import testmod

		testmod()


