Set the Python file maximum line length to 88 characters (TheAlgorithms#2122)

* flake8 --max-line-length=88

* fixup! Format Python code with psf/black push

Co-authored-by: github-actions <${GITHUB_ACTOR}@users.noreply.github.com>

Author: cclauss

.travis.yml

@@ -10,7 +10,7 @@ notifications:
     on_success: never
 before_script:
   - black --check . || true
-  - flake8 --ignore=E203,W503 --max-complexity=25 --max-line-length=120 --statistics --count .
+  - flake8 --ignore=E203,W503 --max-complexity=25 --max-line-length=88 --statistics --count .
   - scripts/validate_filenames.py  # no uppercase, no spaces, in a directory
   - pip install -r requirements.txt  # fast fail on black, flake8, validate_filenames
 script:

arithmetic_analysis/intersection.py

@@ -1,9 +1,11 @@
 import math
 
 
-def intersection(
-    function, x0, x1
-):  # function is the f we want to find its root and x0 and x1 are two random starting points
+def intersection(function, x0, x1):
+    """
+    function is the f we want to find its root
+    x0 and x1 are two random starting points
+    """
     x_n = x0
     x_n1 = x1
     while True:

backtracking/hamiltonian_cycle.py

@@ -16,8 +16,8 @@ def valid_connection(
     Checks whether it is possible to add next into path by validating 2 statements
     1. There should be path between current and next vertex
     2. Next vertex should not be in path
-    If both validations succeeds we return true saying that it is possible to connect this vertices
-    either we return false
+    If both validations succeeds we return True saying that it is possible to connect
+    this vertices either we return False
 
     Case 1:Use exact graph as in main function, with initialized values
     >>> graph = [[0, 1, 0, 1, 0],
@@ -52,7 +52,8 @@ def util_hamilton_cycle(graph: List[List[int]], path: List[int], curr_ind: int)
     Pseudo-Code
     Base Case:
     1. Chceck if we visited all of vertices
-        1.1 If last visited vertex has path to starting vertex return True either return False
+        1.1 If last visited vertex has path to starting vertex return True either
+            return False
     Recursive Step:
     2. Iterate over each vertex
         Check if next vertex is valid for transiting from current vertex
@@ -74,7 +75,8 @@ def util_hamilton_cycle(graph: List[List[int]], path: List[int], curr_ind: int)
     >>> print(path)
     [0, 1, 2, 4, 3, 0]
 
-    Case 2: Use exact graph as in previous case, but in the properties taken from middle of calculation
+    Case 2: Use exact graph as in previous case, but in the properties taken from
+        middle of calculation
     >>> graph = [[0, 1, 0, 1, 0],
     ...          [1, 0, 1, 1, 1],
     ...          [0, 1, 0, 0, 1],

backtracking/n_queens.py

@@ -12,8 +12,8 @@
 
 def isSafe(board, row, column):
     """
-    This function returns a boolean value True if it is safe to place a queen there considering
-    the current state of the board.
+    This function returns a boolean value True if it is safe to place a queen there
+    considering the current state of the board.
 
     Parameters :
     board(2D matrix) : board
@@ -56,8 +56,8 @@ def solve(board, row):
         return
     for i in range(len(board)):
         """
-        For every row it iterates through each column to check if it is feasible to place a
-        queen there.
+        For every row it iterates through each column to check if it is feasible to
+        place a queen there.
         If all the combinations for that particular branch are successful the board is
         reinitialized for the next possible combination.
         """

backtracking/sum_of_subsets.py

@@ -1,9 +1,10 @@
 """
-        The sum-of-subsetsproblem states that a set of non-negative integers, and a value M,
-        determine all possible subsets of the given set whose summation sum equal to given M.
+        The sum-of-subsetsproblem states that a set of non-negative integers, and a
+        value M, determine all possible subsets of the given set whose summation sum
+        equal to given M.
 
-        Summation of the chosen numbers must be equal to given number M and one number can
-        be used only once.
+        Summation of the chosen numbers must be equal to given number M and one number
+        can be used only once.
 """
 
 
@@ -21,7 +22,8 @@ def create_state_space_tree(nums, max_sum, num_index, path, result, remaining_nu
         Creates a state space tree to iterate through each branch using DFS.
         It terminates the branching of a node when any of the two conditions
         given below satisfy.
-        This algorithm follows depth-fist-search and backtracks when the node is not branchable.
+        This algorithm follows depth-fist-search and backtracks when the node is not
+        branchable.
 
         """
     if sum(path) > max_sum or (remaining_nums_sum + sum(path)) < max_sum:

blockchain/chinese_remainder_theorem.py

@@ -1,8 +1,9 @@
 # Chinese Remainder Theorem:
 # GCD ( Greatest Common Divisor ) or HCF ( Highest Common Factor )
 
-# If GCD(a,b) = 1, then for any remainder ra modulo a and any remainder rb modulo b there exists integer n,
-# such that n = ra (mod a) and n = ra(mod b).  If n1 and n2 are two such integers, then n1=n2(mod ab)
+# If GCD(a,b) = 1, then for any remainder ra modulo a and any remainder rb modulo b
+# there exists integer n, such that n = ra (mod a) and n = ra(mod b).  If n1 and n2 are
+# two such integers, then n1=n2(mod ab)
 
 # Algorithm :
 

blockchain/diophantine_equation.py

@@ -1,5 +1,6 @@
-# Diophantine Equation : Given integers a,b,c ( at least one of a and b != 0), the diophantine equation
-# a*x + b*y = c has a solution (where x and y are integers) iff gcd(a,b) divides c.
+# Diophantine Equation : Given integers a,b,c ( at least one of a and b != 0), the
+# diophantine equation a*x + b*y = c has a solution (where x and y are integers)
+# iff gcd(a,b) divides c.
 
 # GCD ( Greatest Common Divisor ) or HCF ( Highest Common Factor )
 
@@ -29,8 +30,9 @@ def diophantine(a, b, c):
 
 # Finding All solutions of Diophantine Equations:
 
-# Theorem : Let gcd(a,b) = d, a = d*p, b = d*q. If (x0,y0) is a solution of Diophantine Equation a*x + b*y = c.
-# a*x0 + b*y0 = c, then all the solutions have the form a(x0 + t*q) + b(y0 - t*p) = c, where t is an arbitrary integer.
+# Theorem : Let gcd(a,b) = d, a = d*p, b = d*q. If (x0,y0) is a solution of Diophantine
+# Equation a*x + b*y = c.  a*x0 + b*y0 = c, then all the solutions have the form
+# a(x0 + t*q) + b(y0 - t*p) = c, where t is an arbitrary integer.
 
 # n is the number of solution you want, n = 2 by default
 
@@ -75,8 +77,9 @@ def greatest_common_divisor(a, b):
     >>> greatest_common_divisor(7,5)
     1
 
-    Note : In number theory, two integers a and b are said to be relatively prime, mutually prime, or co-prime
-           if the only positive integer (factor) that divides both of them is 1  i.e., gcd(a,b) = 1.
+    Note : In number theory, two integers a and b are said to be relatively prime,
+           mutually prime, or co-prime if the only positive integer (factor) that
+           divides both of them is 1  i.e., gcd(a,b) = 1.
 
     >>> greatest_common_divisor(121, 11)
     11
@@ -91,7 +94,8 @@ def greatest_common_divisor(a, b):
     return b
 
 
-# Extended Euclid's Algorithm : If d divides a and b and d = a*x + b*y for integers x and y, then d = gcd(a,b)
+# Extended Euclid's Algorithm : If d divides a and b and d = a*x + b*y for integers
+# x and y, then d = gcd(a,b)
 
 
 def extended_gcd(a, b):

blockchain/modular_division.py

@@ -3,8 +3,8 @@
 
 # GCD ( Greatest Common Divisor ) or HCF ( Highest Common Factor )
 
-# Given three integers a, b, and n, such that gcd(a,n)=1 and n>1, the algorithm should return an integer x such that
-#        0≤x≤n−1, and  b/a=x(modn) (that is, b=ax(modn)).
+# Given three integers a, b, and n, such that gcd(a,n)=1 and n>1, the algorithm should
+# return an integer x such that 0≤x≤n−1, and  b/a=x(modn) (that is, b=ax(modn)).
 
 # Theorem:
 # a has a multiplicative inverse modulo n iff gcd(a,n) = 1
@@ -68,7 +68,8 @@ def modular_division2(a, b, n):
     return x
 
 
-# Extended Euclid's Algorithm : If d divides a and b and d = a*x + b*y for integers x and y, then d = gcd(a,b)
+# Extended Euclid's Algorithm : If d divides a and b and d = a*x + b*y for integers x
+# and y, then d = gcd(a,b)
 
 
 def extended_gcd(a, b):
@@ -123,8 +124,9 @@ def greatest_common_divisor(a, b):
     >>> greatest_common_divisor(7,5)
     1
 
-    Note : In number theory, two integers a and b are said to be relatively prime, mutually prime, or co-prime
-           if the only positive integer (factor) that divides both of them is 1  i.e., gcd(a,b) = 1.
+    Note : In number theory, two integers a and b are said to be relatively prime,
+        mutually prime, or co-prime if the only positive integer (factor) that divides
+        both of them is 1  i.e., gcd(a,b) = 1.
 
     >>> greatest_common_divisor(121, 11)
     11

ciphers/affine_cipher.py

@@ -55,7 +55,8 @@ def check_keys(keyA, keyB, mode):
 
 def encrypt_message(key: int, message: str) -> str:
     """
-    >>> encrypt_message(4545, 'The affine cipher is a type of monoalphabetic substitution cipher.')
+    >>> encrypt_message(4545, 'The affine cipher is a type of monoalphabetic '
+    ...                       'substitution cipher.')
     'VL}p MM{I}p~{HL}Gp{vp pFsH}pxMpyxIx JHL O}F{~pvuOvF{FuF{xIp~{HL}Gi'
     """
     keyA, keyB = divmod(key, len(SYMBOLS))
@@ -72,7 +73,8 @@ def encrypt_message(key: int, message: str) -> str:
 
 def decrypt_message(key: int, message: str) -> str:
     """
-    >>> decrypt_message(4545, 'VL}p MM{I}p~{HL}Gp{vp pFsH}pxMpyxIx JHL O}F{~pvuOvF{FuF{xIp~{HL}Gi')
+    >>> decrypt_message(4545, 'VL}p MM{I}p~{HL}Gp{vp pFsH}pxMpyxIx JHL O}F{~pvuOvF{FuF'
+    ...                       '{xIp~{HL}Gi')
     'The affine cipher is a type of monoalphabetic substitution cipher.'
     """
     keyA, keyB = divmod(key, len(SYMBOLS))

ciphers/base64_cipher.py

@@ -39,7 +39,8 @@ def decode_base64(text):
     'WELCOME to base64 encoding 😁'
     >>> decode_base64('QcOF4ZCD8JCAj/CfpJM=')
     'AÅᐃ𐀏🤓'
-    >>> decode_base64("QUFBQUFBQUFBQUFBQUFBQUFBQUFBQUFBQUFBQUFBQUFBQUFBQUFBQUFBQUFBQUFBQUFBQUFBQUFB\r\nQUFB")
+    >>> decode_base64("QUFBQUFBQUFBQUFBQUFBQUFBQUFBQUFBQUFBQUFBQUFBQUFBQUFBQUFBQUFBQUF"
+    ...               "BQUFBQUFBQUFB\r\nQUFB")
     'AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA'
     """
     base64_chars = "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/"