
def 		SCREAMING_SNAKE_CASE__      ( __lowerCAmelCase							):
    if len(__lowerCAmelCase							) == 0 or not all(len(__lowerCAmelCase							) == 2 for pair in coordinates							):
        raise ValueError("The program cannot work out a fitting polynomial."							)

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

    snake_case__  =			{x for x, _ in coordinates}
    if len(__lowerCAmelCase							) == 1:
        return F"""x={coordinates[0][0]}"""

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

    snake_case__  =			len(__lowerCAmelCase							)

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

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

    snake_case__  =			0

    while count < x:
        snake_case__  =			0
        while zahlen < x:
            if count == zahlen:
                zahlen += 1
            if zahlen == x:
                break
            snake_case__  =			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

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

    snake_case__  =			0
    snake_case__  =			"f(x)="

    while count < x:
        snake_case__  =			solution[count].split("E"							)
        if len(__lowerCAmelCase							) > 1:
            snake_case__  =			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]]))





def 		SCREAMING_SNAKE_CASE__      ( __lowerCAmelCase							):
    if len(__lowerCAmelCase							) > 1:
        snake_case__  =			len(__lowerCAmelCase							) // 2  # Finds the middle of the array
        snake_case__  =			arr[
            :middle_length
        ]  # Creates an array of the elements in the first half.
        snake_case__  =			arr[
            middle_length:
        ]  # Creates an array of the elements in the second half.
        snake_case__  =			len(__lowerCAmelCase							)
        snake_case__  =			len(__lowerCAmelCase							)
        merge(__lowerCAmelCase							)  # Starts sorting the left.
        merge(__lowerCAmelCase							)  # Starts sorting the right
        snake_case__  =			0  # Left Counter
        snake_case__  =			0  # Right Counter
        snake_case__  =			0  # Position Counter
        while (
            left_index < left_size and right_index < right_size
        ):  # Runs until the lowers size of the left and right are sorted.
            if left_array[left_index] < right_array[right_index]:
                snake_case__  =			left_array[left_index]
                left_index += 1
            else:
                snake_case__  =			right_array[right_index]
                right_index += 1
            index += 1
        while (
            left_index < left_size
        ):  # Adds the left over elements in the left half of the array
            snake_case__  =			left_array[left_index]
            left_index += 1
            index += 1
        while (
            right_index < right_size
        ):  # Adds the left over elements in the right half of the array
            snake_case__  =			right_array[right_index]
            right_index += 1
            index += 1
    return arr


if __name__ == "__main__":
     import doctest

     doctest.testmod()



