Reduce the complexity of linear_algebra/src/polynom_for_points.py

.flake8

@@ -1,7 +1,7 @@
 [flake8]
 max-line-length = 88
 # max-complexity should be 10
-max-complexity = 23
+max-complexity = 21
 extend-ignore =
     # Formatting style for `black`
     E203  # Whitespace before ':'

linear_algebra/src/polynom_for_points.py

@@ -24,96 +24,79 @@ def points_to_polynomial(coordinates: list[list[int]]) -> str:
     >>> print(points_to_polynomial([[1, 5], [2, 2], [3, 9]]))
     f(x)=x^2*5.0+x^1*-18.0+x^0*18.0
     """
-    try:
-        check = 1
-        more_check = 0
-        d = coordinates[0][0]
-        for j in range(len(coordinates)):
-            if j == 0:
-                continue
-            if d == coordinates[j][0]:
-                more_check += 1
-                solved = "x=" + str(coordinates[j][0])
-                if more_check == len(coordinates) - 1:
-                    check = 2
-                    break
-                elif more_check > 0 and more_check != len(coordinates) - 1:
-                    check = 3
-                else:
-                    check = 1
+    if len(coordinates) == 0 or not all(len(pair) == 2 for pair in coordinates):
+        return "The program cannot work out a fitting polynomial."
+
+    if len({tuple(pair) for pair in coordinates}) != len(coordinates):
+        return "The program cannot work out a fitting polynomial."
 
-        if len(coordinates) == 1 and coordinates[0][0] == 0:
-            check = 2
-            solved = "x=0"
-    except Exception:
-        check = 3
+    set_x = {x for x, _ in coordinates}
+    if len(set_x) == 1:
+        return f"x={coordinates[0][0]}"
+
+    if len(set_x) != len(coordinates):
+        return "The program cannot work out a fitting polynomial."
 
     x = len(coordinates)
 
-    if check == 1:
-        count_of_line = 0
-        matrix: list[list[float]] = []
-        # put the x and x to the power values in a matrix
-        while count_of_line < x:
-            count_in_line = 0
-            a = coordinates[count_of_line][0]
-            count_line: list[float] = []
-            while count_in_line < x:
-                count_line.append(a ** (x - (count_in_line + 1)))
-                count_in_line += 1
-            matrix.append(count_line)
-            count_of_line += 1
+    count_of_line = 0
+    matrix: list[list[float]] = []
+    # put the x and x to the power values in a matrix
+    while count_of_line < x:
+        count_in_line = 0
+        a = coordinates[count_of_line][0]
+        count_line: list[float] = []
+        while count_in_line < x:
+            count_line.append(a ** (x - (count_in_line + 1)))
+            count_in_line += 1
+        matrix.append(count_line)
+        count_of_line += 1
 
-        count_of_line = 0
-        # put the y values into a vector
-        vector: list[float] = []
-        while count_of_line < x:
-            vector.append(coordinates[count_of_line][1])
-            count_of_line += 1
+    count_of_line = 0
+    # put the y values into a vector
+    vector: list[float] = []
+    while count_of_line < x:
+        vector.append(coordinates[count_of_line][1])
+        count_of_line += 1
 
-        count = 0
+    count = 0
 
-        while count < x:
-            zahlen = 0
-            while zahlen < x:
-                if count == zahlen:
-                    zahlen += 1
-                if zahlen == x:
-                    break
-                bruch = 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
+    while count < x:
+        zahlen = 0
+        while zahlen < x:
+            if count == zahlen:
                 zahlen += 1
-            count += 1
-
-        count = 0
-        # make solutions
-        solution: list[str] = []
-        while count < x:
-            solution.append(str(vector[count] / matrix[count][count]))
-            count += 1
+            if zahlen == x:
+                break
+            bruch = 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
 
-        count = 0
-        solved = "f(x)="
+    count = 0
+    # make solutions
+    solution: list[str] = []
+    while count < x:
+        solution.append(str(vector[count] / matrix[count][count]))
+        count += 1
 
-        while count < x:
-            remove_e: list[str] = solution[count].split("E")
-            if len(remove_e) > 1:
-                solution[count] = remove_e[0] + "*10^" + remove_e[1]
-            solved += "x^" + str(x - (count + 1)) + "*" + str(solution[count])
-            if count + 1 != x:
-                solved += "+"
-            count += 1
+    count = 0
+    solved = "f(x)="
 
-        return solved
+    while count < x:
+        remove_e: list[str] = solution[count].split("E")
+        if len(remove_e) > 1:
+            solution[count] = f"{remove_e[0]}*10^{remove_e[1]}"
+        solved += f"x^{x - (count + 1)}*{solution[count]}"
+        if count + 1 != x:
+            solved += "+"
+        count += 1
 
-    elif check == 2:
-        return solved
-    else:
-        return "The program cannot work out a fitting polynomial."
+    return solved
 
 
 if __name__ == "__main__":