Reduce the complexity of linear_algebra/src/polynom_for_points.py (#8605)

* Reduce the complexity of linear_algebra/src/polynom_for_points.py

* updating DIRECTORY.md

* [pre-commit.ci] auto fixes from pre-commit.com hooks

for more information, see https://pre-commit.ci

* Fix

* Fix review issues

---------

Co-authored-by: github-actions <${GITHUB_ACTOR}@users.noreply.github.com>
Co-authored-by: pre-commit-ci[bot] <66853113+pre-commit-ci[bot]@users.noreply.github.com>

linear_algebra/src/polynom_for_points.py

@@ -43,62 +43,43 @@ def points_to_polynomial(coordinates: list[list[int]]) -> str:
 
     x = len(coordinates)
 
-    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:
+    matrix: list[list[float]] = [
-        count_in_line = 0
+        [
-        a = coordinates[count_of_line][0]
+            coordinates[count_of_line][0] ** (x - (count_in_line + 1))
-        count_line: list[float] = []
+            for count_in_line in range(x)
-        while count_in_line < x:
+        ]
-            count_line.append(a ** (x - (count_in_line + 1)))
+        for count_of_line in range(x)
-            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] = []
+    vector: list[float] = [coordinates[count_of_line][1] for count_of_line in range(x)]
-    while count_of_line < x:
-        vector.append(coordinates[count_of_line][1])
-        count_of_line += 1
 
-    count = 0
+    for count in range(x):
-
+        for number in range(x):
-    while count < x:
+            if count == number:
-        zahlen = 0
+                continue
-        while zahlen < x:
+            fraction = matrix[number][count] / matrix[count][count]
-            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
+                matrix[number][counting_columns] -= item * fraction
             # manipulating the values in the vector
-            vector[zahlen] -= vector[count] * bruch
+            vector[number] -= vector[count] * fraction
-            zahlen += 1
-        count += 1
 
-    count = 0
     # make solutions
-    solution: list[str] = []
+    solution: list[str] = [
-    while count < x:
+        str(vector[count] / matrix[count][count]) for count in range(x)
-        solution.append(str(vector[count] / matrix[count][count]))
+    ]
-        count += 1
 
-    count = 0
     solved = "f(x)="
 
-    while count < x:
+    for count in range(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
 
     return solved