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 collections import defaultdict
  
  
  
  
  def 						_UpperCamelCase			(  A = 5			):
     UpperCamelCase_     =defaultdict(A			)
     UpperCamelCase_     =0
  
     while True:
        UpperCamelCase_     =get_digits(A			)
        freqs[digits].append(A			)
  
        if len(freqs[digits]			) == max_base:
           UpperCamelCase_     =freqs[digits][0] ** 3
           return base
  
        num += 1
  
  
  
  
  def 						_UpperCamelCase			(  A			):
     return "".join(sorted(str(num**3			)			)			)
  
  
  if __name__ == "__main__":
      print(f'''{solution() = }''')
  