edson-github · sourcery-ai · Dec 14, 2023 · sourcery-ai · Dec 14, 2023 · sourcery-ai
diff --git a/algorithms/bit_manipulation/sum_of_two_integers.py b/algorithms/bit_manipulation/sum_of_two_integers.py
@@ -18,5 +18,4 @@ def getSum(a, b):
             carry = carry << 1
             a = diff
             b = carry
-        if b > 0: return (a & mask)
-        else: return a
+        return (a & mask) if b > 0 else a
diff --git a/algorithms/dynamic_programming/01_knapsack.py b/algorithms/dynamic_programming/01_knapsack.py
@@ -7,7 +7,7 @@ def knapsack(values, weights, total):
     # rows are the number of items
     # columns are the values of weights required
 
-    t = [[0 for i in range(cols)] for i in range(rows)]
+    t = [[0 for _ in range(cols)] for _ in range(rows)]
 
     for i in range(1, rows):
         for j in range(1, cols):

diff --git a/algorithms/dynamic_programming/Z_Algorithm.py b/algorithms/dynamic_programming/Z_Algorithm.py
@@ -18,13 +18,9 @@ def z_function(text:str , size:int):
                 z[i] = min(r - i + 1 , z[i - l])
             while i + z[i] < len(text) and text[z[i]] == text[i + z[i]]:
                 z[i] += 1
-            
+
             if i + z[i] - 1 > r:
                 l = i
                 r = i + z[i] - 1
-
-        res = []
-        for i in range(size , len(text)):
-            if z[i] == size:
-                res.append(i - size - 1)
-        return res
+
+        return [i - size - 1 for i in range(size , len(text)) if z[i] == size]
diff --git a/algorithms/dynamic_programming/longest_common_subsequence.py b/algorithms/dynamic_programming/longest_common_subsequence.py
@@ -2,7 +2,7 @@ def lcs(s1, s2):
     cols = len(s1) + 1
     rows = len(s2) + 1
 
-    t = [[0 for i in range(cols)] for i in range(rows)]
+    t = [[0 for _ in range(cols)] for _ in range(rows)]
 
     max_length = 0
 

diff --git a/algorithms/dynamic_programming/longest_common_substring.py b/algorithms/dynamic_programming/longest_common_substring.py
@@ -2,7 +2,7 @@ def lcs(s1, s2):
     cols = len(s1) + 1
     rows = len(s2) + 1
 
-    t = [[0 for i in range(cols)] for i in range(rows)]
+    t = [[0 for _ in range(cols)] for _ in range(rows)]
 
     max_length = 0
 

diff --git a/algorithms/dynamic_programming/longest_consecutive_subsequence.py b/algorithms/dynamic_programming/longest_consecutive_subsequence.py
@@ -13,20 +13,16 @@
 """
 
 def find_seq(arr, n):
-    s = set()
-
-    for num in arr:
-        s.add(num)
-
+    s = set(arr)
     ans = 0
     elements = []
 
     for i in range(n):
-        temp = []
-
         if arr[i] - 1 not in s:
             j = arr[i]
 
+            temp = []
+
             while j in s:
                 temp.append(j)
                 j += 1

diff --git a/algorithms/dynamic_programming/longest_palindromic_substring.py b/algorithms/dynamic_programming/longest_palindromic_substring.py
@@ -1,6 +1,6 @@
 def longest_palindromic_substring_DP(s):
 
-    S = [[False for i in range(len(s))] for j in range(len(s))]
+    S = [[False for _ in range(len(s))] for _ in range(len(s))]
 
     max_palindrome = ""
 
@@ -23,10 +23,10 @@ def longest_palindromic_substring_expansion(s):
     max_palindrome = ""
 
     for i in range(len(s) * 2 - 1):
+        # This is when you are "on" an actual character
+        # o = offset, ind = current character
+        o = 0
         if i % 2 == 0:
-            # This is when you are "on" an actual character
-            # o = offset, ind = current character
-            o = 0
             ind = i // 2
             while ind + o < len(s) and ind - o >= 0:
                 if(s[ind + o] != s[ind - o]):
@@ -35,9 +35,6 @@ def longest_palindromic_substring_expansion(s):
                     max_palindrome = s[ind-o:ind+o + 1]
                 o += 1
         else:
-            # This is when you are "in the middle of" two characters
-            # o = offset, sind = start char, eind = end char
-            o = 0
             sind = i // 2
             eind = i // 2 + 1
             while sind - o >= 0 and eind + o < len(s):
@@ -54,4 +51,4 @@ def longest_palindromic_substring_expansion(s):
 
 ans_DP = longest_palindromic_substring_DP(input_string)
 ans_expansion = longest_palindromic_substring_expansion(input_string)
-print("DP Solution: {}, Expansion Solution: {}".format(ans_DP, ans_expansion))
+print(f"DP Solution: {ans_DP}, Expansion Solution: {ans_expansion}")
diff --git a/algorithms/dynamic_programming/longest_subarray_sum_divisible_by_k.py b/algorithms/dynamic_programming/longest_subarray_sum_divisible_by_k.py
@@ -39,15 +39,14 @@ def find_length(arr, k):
     for i in range(0, len(mod_arr)):
         if mod_arr[i] == 0:
             length += 1
+        elif mod_arr[i] in hash_table:
+            if length < (i - mod_arr[i]):
+                length = i - mod_arr[i]
+                start = mod_arr[i]
+                end = i - 1 # i-1 because the current number is not to considered as it makes the sum not divisible by k
+
         else:
-            if mod_arr[i] not in hash_table:
-                hash_table[mod_arr[i]] = i
-            else:
-                if length < (i - mod_arr[i]):
-                    length = i - mod_arr[i]
-                    start = mod_arr[i]
-                    end = i - 1 # i-1 because the current number is not to considered as it makes the sum not divisible by k
-
+            hash_table[mod_arr[i]] = i
     return length, arr[start:end+1]
 
 

diff --git a/algorithms/greedy/activity_selection.py b/algorithms/greedy/activity_selection.py
@@ -7,16 +7,11 @@
 
 def find_activities(arr):
     n = len(arr)
-    selected = []
-
     arr.sort(key = lambda x: x[1])
 
     i = 0
 
-    # since it is a greedy algorithm, the first acitivity is always
-    # selected because it is the most optimal choice at that point
-    selected.append(arr[i])
-
+    selected = [arr[i]]
     for j in range(1, n):
         start_time_next_activity = arr[j][0]
         end_time_prev_activity = arr[i][1]

diff --git a/algorithms/greedy/cost_of_tiles.py b/algorithms/greedy/cost_of_tiles.py
@@ -18,20 +18,19 @@ def cost(arr, A, B):
 
     for i in range(n):
         j = 0
-        
+
         while j < m:
             if arr[i][j] == '*':  # tile is already there
                 j += 1
                 continue
 
             if j == m - 1:  # if j is pointing to last tile, you can use only 1*1 tile
                 ans += A
+            elif arr[i][j+1] == '.':
+                ans += min(2 * A, B)
+                j += 1
             else:
-                if arr[i][j+1] == '.':
-                    ans += min(2 * A, B)
-                    j += 1
-                else:
-                    ans += A
+                ans += A
 
             j += 1
 

diff --git a/algorithms/greedy/dijkstra_greedy.py b/algorithms/greedy/dijkstra_greedy.py
@@ -1,23 +1,19 @@
 def dijkstra(graph, start, end):
-    shortest_distance = {}
-    non_visited_nodes = {}
-    for i in graph:
-        non_visited_nodes[i] = graph[i]
-
+    non_visited_nodes = {i: graph[i] for i in graph}
     infinit = float('inf')
 
-    for no in non_visited_nodes:
-        shortest_distance[no] = infinit
+    shortest_distance = {no: infinit for no in non_visited_nodes}
     shortest_distance[start] = 0
-    
+
     while non_visited_nodes != {}:
         shortest_extracted_node = None
         for i in non_visited_nodes:
-            if shortest_extracted_node is None:
-                shortest_extracted_node = i
-            elif shortest_distance[i] < shortest_distance[shortest_extracted_node]:
+            if (
+                shortest_extracted_node is None
+                or shortest_distance[i]
+                < shortest_distance[shortest_extracted_node]
+            ):
                 shortest_extracted_node = i
-
         for no_v, Weight in graph[shortest_extracted_node]:
             if Weight + shortest_distance[shortest_extracted_node] < shortest_distance[no_v]:
                 shortest_distance[no_v] = Weight + shortest_distance[shortest_extracted_node]
@@ -31,7 +27,7 @@ def dijkstra(graph, start, end):
 
 cities, origin, destiny = map(int, input().split())
 graph = {i:[] for i in range(1, cities+1)}
-for i in range(cities-1):
+for _ in range(cities-1):
     u, v, w = map(int, input().split())
     graph[v].append((u, w))
     graph[u].append((v, w))
diff --git a/algorithms/greedy/min_platforms.py b/algorithms/greedy/min_platforms.py
@@ -21,7 +21,7 @@ def find_platforms(arrival, departure):
             plat += 1
             i += 1
 
-        elif arrival[i] > departure[j]:
+        else:
             plat -= 1
             j += 1
 

diff --git a/algorithms/math/divisors.py b/algorithms/math/divisors.py
@@ -3,46 +3,28 @@
 class divisors:
 
     def findAllDivisors(self, n):
-        result = list()
-
-        for i in range(1, n+1):
-            if (n%i == 0): 
-                result.append(i)
-
-        return result
+        return [i for i in range(1, n+1) if (n%i == 0)]
 
     def divisorsCount(self, n):
         divs = self.findAllDivisors(n)
         return len(divs)
 
     def oddFactors(self, n):
-        result = list()
-
-        for i in range(1, n+1):
-            if (n%i == 0 and i%2==1): 
-                result.append(i)
-
-        return result
+        return [i for i in range(1, n+1) if (n%i == 0 and i%2==1)]
 
     def oddFactorsSum(self, n):
         divs = self.evenFactors(n)
         return sum(divs)
 
     def evenFactors(self, n):
-        result = list()
-
-        for i in range(1, n+1):
-            if (n%i == 0 and i%2==0): 
-                result.append(i)
-
-        return result
+        return [i for i in range(1, n+1) if (n%i == 0 and i%2==0)]
 
     def evenFactorsSum(self, n):
         divs = self.evenFactors(n)
         return sum(divs)
 
     def primeFactors(self, n):
-        result = list()
+        result = []
 
         while n % 2 == 0: 
             result.append(2) 
@@ -52,10 +34,10 @@ def primeFactors(self, n):
             while n % i== 0: 
                 result.append(i) 
                 n = n / i 
-                
+
         if n > 2: 
             result.append(n)
-        
+
         return result
 
     def primeFactorsSum(self, n):

diff --git a/algorithms/math/factorial_iterative.py b/algorithms/math/factorial_iterative.py
@@ -6,9 +6,8 @@ def factorial(number):
 
     if number == 0:
         return 1
-    else:
-        for num in range(1, number+1):
-            answer = answer * num
+    for num in range(1, number+1):
+        answer = answer * num
     return answer
 
 if __name__ == '__main__':

diff --git a/algorithms/math/factorial_recursive.py b/algorithms/math/factorial_recursive.py
@@ -2,12 +2,7 @@
 
 def factorial(number):
 
-    if number == 0 or number == 1:
-        return 1
-
-    answer = number * factorial(number - 1)
-
-    return answer
+    return 1 if number in [0, 1] else number * factorial(number - 1)
 
 if __name__ == '__main__':
 

diff --git a/algorithms/math/greatest_common_divisor.py b/algorithms/math/greatest_common_divisor.py
@@ -23,10 +23,7 @@ def gcd(x, y):
 def gcd(x, y):
 	if x == 0:
 		return y
-	if y == 0:
-		return x
-
-	return gcd(y, x % y)
+	return x if y == 0 else gcd(y, x % y)
 
 # Iterative optimized 
 def gcd(x, y):

diff --git a/algorithms/math/number_convertion.py b/algorithms/math/number_convertion.py
@@ -18,10 +18,7 @@ def verify_base(x):
     try:
         return int(x)
     except:
-        if x in bases:
-            return bases[x]
-        else:
-            return default
+        return bases[x] if x in bases else default
 
 
 def decimal_value(x):
@@ -91,10 +88,10 @@ def convert(n, from_base, to_base):
             decimal_number += (multi * decimal_value(n[i]))
             multi *= from_base
 
-    if(to_base == 10):
+    if (to_base == 10):
         decimal_number = str(decimal_number)
-        if(negative):
-            decimal_number = '-' + decimal_number
+        if negative:
+            decimal_number = f'-{decimal_number}'
 
         return decimal_number
 
@@ -105,8 +102,8 @@ def convert(n, from_base, to_base):
         result = to_special_caracter(value) + result
         decimal_number = int((decimal_number - value)/to_base)
 
-    if(negative):
-            result = '-' + result
+    if negative:
+        result = f'-{result}'
 
     return result
 

diff --git a/algorithms/math/perfect_square.py b/algorithms/math/perfect_square.py
@@ -8,12 +8,9 @@ def is_perfect_square(num):
     :rtype: bool
     """
     i = 0
-    while i * i < num:
+    while i**2 < num:
         i += 1
-    if i * i == num:
-        return True
-    else:
-        return False
+    return i**2 == num
 
 
 # Test

diff --git a/algorithms/math/recursive_fibonacci.py b/algorithms/math/recursive_fibonacci.py
@@ -12,7 +12,7 @@ def rec_fib(n):
         return rec_fib(n-1)+rec_fib(n-2)
 
 def binary_rec_fib(n):
-    if n == 2 or n == 1:
+    if n in [2, 1]:
         return 1
     elif n == 0:
         return 0
-Original file line number
+Diff line change
@@ Expand Up / @@ -21,7 +21,7 @@ def find_platforms(arrival, departure): @@
                 plat += 1
                 i += 1
-            elif arrival[i] > departure[j]:
+            else:
                 plat -= 1
                 j += 1
@@ Expand Down @@