code: 
  
  
  
  
  
  
  """simple docstring"""
  
  
  
  
  
  
  def 						_UpperCamelCase			(  A			):
  			if len(A			) == 0 or not all(len(A			) == 2 for pair in coordinates			):
  						raise ValueError("The program cannot work out a fitting polynomial."			)
  
  			if len({tuple(A			) for pair in coordinates}			) != len(A			):
  						raise ValueError("The program cannot work out a fitting polynomial."			)
  
  			UpperCamelCase_     ={x for x, _ in coordinates}
  			if len(A			) == 1:
  						return f"""x={coordinates[0][0]}"""
  
  			if len(A			) != len(A			):
  						raise ValueError("The program cannot work out a fitting polynomial."			)
  
  			UpperCamelCase_     =len(A			)
  
  			UpperCamelCase_     =0
  			UpperCamelCase_     =[]
  			# put the x and x to the power values in a matrix
  			while count_of_line < x:
  						UpperCamelCase_     =0
  						UpperCamelCase_     =coordinates[count_of_line][0]
  						UpperCamelCase_     =[]
  						while count_in_line < x:
  									count_line.append(a ** (x - (count_in_line + 1))			)
  									count_in_line += 1
  						matrix.append(A			)
  						count_of_line += 1
  
  			UpperCamelCase_     =0
  			# put the y values into a vector
  			UpperCamelCase_     =[]
  			while count_of_line < x:
  						vector.append(coordinates[count_of_line][1]			)
  						count_of_line += 1
  
  			UpperCamelCase_     =0
  
  			while count < x:
  						UpperCamelCase_     =0
  						while zahlen < x:
  									if count == zahlen:
  												zahlen += 1
  									if zahlen == x:
  												break
  									UpperCamelCase_     =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
  
  			UpperCamelCase_     =0
  			# make solutions
  			UpperCamelCase_     =[]
  			while count < x:
  						solution.append(str(vector[count] / matrix[count][count]			)			)
  						count += 1
  
  			UpperCamelCase_     =0
  			UpperCamelCase_     ="f(x)="
  
  			while count < x:
  						UpperCamelCase_     =solution[count].split("E"			)
  						if len(A			) > 1:
  									UpperCamelCase_     =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]]))
  
style_context: 
  
  
  
  
  
  
  """simple docstring"""
  
  
  
  
  
  
  from .hash_table import HashTable
  from .number_theory.prime_numbers import is_prime, next_prime
  class 						__lowerCAmelCase   (			UpperCAmelCase       ):
  
  
  
  
  
  
  
    '''simple docstring'''
  
  
    def __init__(      self:		List[Any]				,			*UpperCamelCase_:		Dict				,			**UpperCamelCase_:		Optional[int]					):
       super().__init__(*UpperCamelCase_				,			**UpperCamelCase_					)
    def 					UpperCamelCase__   (      self:		Any				,			UpperCamelCase_:		Optional[int]				,			UpperCamelCase_:		Optional[int]					):
       UpperCamelCase_     =(
           next_prime(value % self.size_table					)
           if not is_prime(value % self.size_table					)
           else value % self.size_table
       )  # gt = bigger than
       return next_prime_gt - (data % next_prime_gt)
    def 					UpperCamelCase__   (      self:		str				,			UpperCamelCase_:		List[str]				,			UpperCamelCase_:		str				,			UpperCamelCase_:		Tuple					):
       return (increment * self.__hash_function_a(UpperCamelCase_				,			UpperCamelCase_					)) % self.size_table
  
  
  
  
  
    def 					UpperCamelCase__   (      self:		str				,			UpperCamelCase_:		int				,			UpperCamelCase_:		str=None					):
       UpperCamelCase_     =1
       UpperCamelCase_     =self.hash_function(UpperCamelCase_					)
  
       while self.values[new_key] is not None and self.values[new_key] != key:
          UpperCamelCase_     =(
              self.__hash_double_function(UpperCamelCase_				,			UpperCamelCase_				,			UpperCamelCase_					)
              if self.balanced_factor() >= self.lim_charge
              else None
          )
          if new_key is None:
             break
          else:
             i += 1
  
       return new_key
  