Enable ruff E741 rule (TheAlgorithms#11370)

* Enable ruff E741 rule

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

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

---------

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

Author: MaximSmolskiy

data_structures/binary_tree/non_recursive_segment_tree.py

@@ -87,12 +87,12 @@ def update(self, p: int, v: T) -> None:
             p = p // 2
             self.st[p] = self.fn(self.st[p * 2], self.st[p * 2 + 1])
 
-    def query(self, l: int, r: int) -> T | None:
+    def query(self, left: int, right: int) -> T | None:
         """
         Get range query value in log(N) time
-        :param l: left element index
-        :param r: right element index
-        :return: element combined in the range [l, r]
+        :param left: left element index
+        :param right: right element index
+        :return: element combined in the range [left, right]
 
         >>> st = SegmentTree([1, 2, 3, 4], lambda a, b: a + b)
         >>> st.query(0, 2)
@@ -104,15 +104,15 @@ def query(self, l: int, r: int) -> T | None:
         >>> st.query(2, 3)
         7
         """
-        l, r = l + self.N, r + self.N
+        left, right = left + self.N, right + self.N
 
         res: T | None = None
-        while l <= r:
-            if l % 2 == 1:
-                res = self.st[l] if res is None else self.fn(res, self.st[l])
-            if r % 2 == 0:
-                res = self.st[r] if res is None else self.fn(res, self.st[r])
-            l, r = (l + 1) // 2, (r - 1) // 2
+        while left <= right:
+            if left % 2 == 1:
+                res = self.st[left] if res is None else self.fn(res, self.st[left])
+            if right % 2 == 0:
+                res = self.st[right] if res is None else self.fn(res, self.st[right])
+            left, right = (left + 1) // 2, (right - 1) // 2
         return res
 
 

data_structures/binary_tree/segment_tree.py

@@ -35,13 +35,13 @@ def right(self, idx):
         """
         return idx * 2 + 1
 
-    def build(self, idx, l, r):
-        if l == r:
-            self.st[idx] = self.A[l]
+    def build(self, idx, left, right):
+        if left == right:
+            self.st[idx] = self.A[left]
         else:
-            mid = (l + r) // 2
-            self.build(self.left(idx), l, mid)
-            self.build(self.right(idx), mid + 1, r)
+            mid = (left + right) // 2
+            self.build(self.left(idx), left, mid)
+            self.build(self.right(idx), mid + 1, right)
             self.st[idx] = max(self.st[self.left(idx)], self.st[self.right(idx)])
 
     def update(self, a, b, val):
@@ -56,18 +56,18 @@ def update(self, a, b, val):
         """
         return self.update_recursive(1, 0, self.N - 1, a - 1, b - 1, val)
 
-    def update_recursive(self, idx, l, r, a, b, val):
+    def update_recursive(self, idx, left, right, a, b, val):
         """
         update(1, 1, N, a, b, v) for update val v to [a,b]
         """
-        if r < a or l > b:
+        if right < a or left > b:
             return True
-        if l == r:
+        if left == right:
             self.st[idx] = val
             return True
-        mid = (l + r) // 2
-        self.update_recursive(self.left(idx), l, mid, a, b, val)
-        self.update_recursive(self.right(idx), mid + 1, r, a, b, val)
+        mid = (left + right) // 2
+        self.update_recursive(self.left(idx), left, mid, a, b, val)
+        self.update_recursive(self.right(idx), mid + 1, right, a, b, val)
         self.st[idx] = max(self.st[self.left(idx)], self.st[self.right(idx)])
         return True
 
@@ -83,17 +83,17 @@ def query(self, a, b):
         """
         return self.query_recursive(1, 0, self.N - 1, a - 1, b - 1)
 
-    def query_recursive(self, idx, l, r, a, b):
+    def query_recursive(self, idx, left, right, a, b):
         """
         query(1, 1, N, a, b) for query max of [a,b]
         """
-        if r < a or l > b:
+        if right < a or left > b:
             return -math.inf
-        if l >= a and r <= b:
+        if left >= a and right <= b:
             return self.st[idx]
-        mid = (l + r) // 2
-        q1 = self.query_recursive(self.left(idx), l, mid, a, b)
-        q2 = self.query_recursive(self.right(idx), mid + 1, r, a, b)
+        mid = (left + right) // 2
+        q1 = self.query_recursive(self.left(idx), left, mid, a, b)
+        q2 = self.query_recursive(self.right(idx), mid + 1, right, a, b)
         return max(q1, q2)
 
     def show_data(self):

data_structures/heap/min_heap.py

@@ -66,14 +66,14 @@ def build_heap(self, array):
     # this is min-heapify method
     def sift_down(self, idx, array):
         while True:
-            l = self.get_left_child_idx(idx)
-            r = self.get_right_child_idx(idx)
+            left = self.get_left_child_idx(idx)
+            right = self.get_right_child_idx(idx)
 
             smallest = idx
-            if l < len(array) and array[l] < array[idx]:
-                smallest = l
-            if r < len(array) and array[r] < array[smallest]:
-                smallest = r
+            if left < len(array) and array[left] < array[idx]:
+                smallest = left
+            if right < len(array) and array[right] < array[smallest]:
+                smallest = right
 
             if smallest != idx:
                 array[idx], array[smallest] = array[smallest], array[idx]

dynamic_programming/longest_common_subsequence.py

@@ -38,30 +38,30 @@ def longest_common_subsequence(x: str, y: str):
     n = len(y)
 
     # declaring the array for storing the dp values
-    l = [[0] * (n + 1) for _ in range(m + 1)]
+    dp = [[0] * (n + 1) for _ in range(m + 1)]
 
     for i in range(1, m + 1):
         for j in range(1, n + 1):
             match = 1 if x[i - 1] == y[j - 1] else 0
 
-            l[i][j] = max(l[i - 1][j], l[i][j - 1], l[i - 1][j - 1] + match)
+            dp[i][j] = max(dp[i - 1][j], dp[i][j - 1], dp[i - 1][j - 1] + match)
 
     seq = ""
     i, j = m, n
     while i > 0 and j > 0:
         match = 1 if x[i - 1] == y[j - 1] else 0
 
-        if l[i][j] == l[i - 1][j - 1] + match:
+        if dp[i][j] == dp[i - 1][j - 1] + match:
             if match == 1:
                 seq = x[i - 1] + seq
             i -= 1
             j -= 1
-        elif l[i][j] == l[i - 1][j]:
+        elif dp[i][j] == dp[i - 1][j]:
             i -= 1
         else:
             j -= 1
 
-    return l[m][n], seq
+    return dp[m][n], seq
 
 
 if __name__ == "__main__":

dynamic_programming/longest_increasing_subsequence_o_nlogn.py

@@ -7,14 +7,14 @@
 from __future__ import annotations
 
 
-def ceil_index(v, l, r, key):
-    while r - l > 1:
-        m = (l + r) // 2
-        if v[m] >= key:
-            r = m
+def ceil_index(v, left, right, key):
+    while right - left > 1:
+        middle = (left + right) // 2
+        if v[middle] >= key:
+            right = middle
         else:
-            l = m
-    return r
+            left = middle
+    return right
 
 
 def longest_increasing_subsequence_length(v: list[int]) -> int:

graphs/articulation_points.py

@@ -1,6 +1,6 @@
 # Finding Articulation Points in Undirected Graph
-def compute_ap(l):
-    n = len(l)
+def compute_ap(graph):
+    n = len(graph)
     out_edge_count = 0
     low = [0] * n
     visited = [False] * n
@@ -12,7 +12,7 @@ def dfs(root, at, parent, out_edge_count):
         visited[at] = True
         low[at] = at
 
-        for to in l[at]:
+        for to in graph[at]:
             if to == parent:
                 pass
             elif not visited[to]:
@@ -41,7 +41,7 @@ def dfs(root, at, parent, out_edge_count):
 
 
 # Adjacency list of graph
-data = {
+graph = {
     0: [1, 2],
     1: [0, 2],
     2: [0, 1, 3, 5],
@@ -52,4 +52,4 @@ def dfs(root, at, parent, out_edge_count):
     7: [6, 8],
     8: [5, 7],
 }
-compute_ap(data)
+compute_ap(graph)

graphs/dinic.py

@@ -37,7 +37,7 @@ def depth_first_search(self, vertex, sink, flow):
     # Here we calculate the flow that reaches the sink
     def max_flow(self, source, sink):
         flow, self.q[0] = 0, source
-        for l in range(31):  # l = 30 maybe faster for random data
+        for l in range(31):  # l = 30 maybe faster for random data  # noqa: E741
             while True:
                 self.lvl, self.ptr = [0] * len(self.q), [0] * len(self.q)
                 qi, qe, self.lvl[source] = 0, 1, 1

machine_learning/sequential_minimum_optimization.py

@@ -309,9 +309,9 @@ def _get_new_alpha(self, i1, i2, a1, a2, e1, e2, y1, y2):
         # calculate L and H  which bound the new alpha2
         s = y1 * y2
         if s == -1:
-            l, h = max(0.0, a2 - a1), min(self._c, self._c + a2 - a1)
+            l, h = max(0.0, a2 - a1), min(self._c, self._c + a2 - a1)  # noqa: E741
         else:
-            l, h = max(0.0, a2 + a1 - self._c), min(self._c, a2 + a1)
+            l, h = max(0.0, a2 + a1 - self._c), min(self._c, a2 + a1)  # noqa: E741
         if l == h:
             return None, None
 

maths/pi_generator.py

@@ -41,7 +41,7 @@ def calculate_pi(limit: int) -> str:
     t = 1
     k = 1
     n = 3
-    l = 3
+    m = 3
 
     decimal = limit
     counter = 0
@@ -65,11 +65,11 @@ def calculate_pi(limit: int) -> str:
             q *= 10
             r = nr
         else:
-            nr = (2 * q + r) * l
-            nn = (q * (7 * k) + 2 + (r * l)) // (t * l)
+            nr = (2 * q + r) * m
+            nn = (q * (7 * k) + 2 + (r * m)) // (t * m)
             q *= k
-            t *= l
-            l += 2
+            t *= m
+            m += 2
             k += 1
             n = nn
             r = nr

other/sdes.py

@@ -44,11 +44,11 @@ def function(expansion, s0, s1, key, message):
     right = message[4:]
     temp = apply_table(right, expansion)
     temp = xor(temp, key)
-    l = apply_sbox(s0, temp[:4])
-    r = apply_sbox(s1, temp[4:])
-    l = "0" * (2 - len(l)) + l
-    r = "0" * (2 - len(r)) + r
-    temp = apply_table(l + r, p4_table)
+    left_bin_str = apply_sbox(s0, temp[:4])
+    right_bin_str = apply_sbox(s1, temp[4:])
+    left_bin_str = "0" * (2 - len(left_bin_str)) + left_bin_str
+    right_bin_str = "0" * (2 - len(right_bin_str)) + right_bin_str
+    temp = apply_table(left_bin_str + right_bin_str, p4_table)
     temp = xor(left, temp)
     return temp + right