[REFACTOR] [FIX] autopep8 massive file format fix.

Author: Gonzalo Diaz

src/hackerrank/interview_preparation_kit/arrays/cruch_bruteforce.py

@@ -14,7 +14,7 @@ def array_manipulation(n: int, queries: list[list[int]]) -> int:
     for [a, b, k] in queries:
 
         LOGGER.debug("start -> %s", result)
-        for j in range(a, b+1):
+        for j in range(a, b + 1):
             result[j] += k
             LOGGER.debug("result -> %s", result)
 

src/hackerrank/interview_preparation_kit/arrays/cruch_optimized.py

@@ -19,7 +19,7 @@ def array_manipulation_optimized(n: int, queries: list[list[int]]) -> int:
     for [a, b, k] in queries:
         # Prefix
         result[a] += k
-        result[b+1] -= k
+        result[b + 1] -= k
 
     accum_sum = 0
     for value in result:

src/hackerrank/interview_preparation_kit/arrays/cruch_testcases_test.py

@@ -1,27 +1,27 @@
 CRUCH_SMALL_TEST_CASES = tests = [
-            {
-                'title': "Sample Test Case 0",
-                'n': 5,
-                'queries': [[1, 2, 100],
-                            [2, 5, 100],
-                            [3, 4, 100]],
-                'answer': 200
-            },
-            {
-                'title': "Sample Test Case 1",
-                'n': 10,
-                'queries': [[1, 5, 3],
-                            [4, 8, 7],
-                            [6, 9, 1]],
-                'answer': 10
-            },
-            {
-                'title': "Sample Test Case 3",
-                'n': 10,
-                'queries': [[2, 6, 8],
-                            [3, 5, 7],
-                            [1, 8, 1],
-                            [5, 9, 15]],
-                'answer': 31
-            },
-        ]
+    {
+        'title': "Sample Test Case 0",
+        'n': 5,
+        'queries': [[1, 2, 100],
+                    [2, 5, 100],
+                    [3, 4, 100]],
+        'answer': 200
+    },
+    {
+        'title': "Sample Test Case 1",
+        'n': 10,
+        'queries': [[1, 5, 3],
+                    [4, 8, 7],
+                    [6, 9, 1]],
+        'answer': 10
+    },
+    {
+        'title': "Sample Test Case 3",
+        'n': 10,
+        'queries': [[2, 6, 8],
+                    [3, 5, 7],
+                    [1, 8, 1],
+                    [5, 9, 15]],
+        'answer': 31
+    },
+]

src/hackerrank/interview_preparation_kit/arrays/ctci_array_left_rotation_test.py

@@ -7,11 +7,11 @@ class TestArrayLeftRotation(unittest.TestCase):
     def test_rot_left_one(self):
 
         tests = [
-          {'input': [1, 2, 3, 4, 5], 'answer': [2, 3, 4, 5, 1]},
-          {'input': [2, 3, 4, 5, 1], 'answer': [3, 4, 5, 1, 2]},
-          {'input': [3, 4, 5, 1, 2], 'answer': [4, 5, 1, 2, 3]},
-          {'input': [4, 5, 1, 2, 3], 'answer': [5, 1, 2, 3, 4]},
-          {'input': [5, 1, 2, 3, 4], 'answer': [1, 2, 3, 4, 5]},
+            {'input': [1, 2, 3, 4, 5], 'answer': [2, 3, 4, 5, 1]},
+            {'input': [2, 3, 4, 5, 1], 'answer': [3, 4, 5, 1, 2]},
+            {'input': [3, 4, 5, 1, 2], 'answer': [4, 5, 1, 2, 3]},
+            {'input': [4, 5, 1, 2, 3], 'answer': [5, 1, 2, 3, 4]},
+            {'input': [5, 1, 2, 3, 4], 'answer': [1, 2, 3, 4, 5]},
         ]
 
         for _, _tt in enumerate(tests):
@@ -24,7 +24,7 @@ def test_rot_left_one(self):
     def test_rot_left(self):
 
         tests = [
-          {'input': [1, 2, 3, 4, 5], 'd': 4, 'answer': [5, 1, 2, 3, 4]},
+            {'input': [1, 2, 3, 4, 5], 'd': 4, 'answer': [5, 1, 2, 3, 4]},
         ]
 
         for _, _tt in enumerate(tests):

src/hackerrank/interview_preparation_kit/arrays/minimum_swaps_2.py

@@ -7,7 +7,7 @@
 
 
 def minimum_swaps(group: list[int]) -> int:
-    q = [i-1 for i in group]
+    q = [i - 1 for i in group]
 
     swaps = 0
     index = 0

src/hackerrank/interview_preparation_kit/arrays/minimum_swaps_2_test.py

@@ -7,9 +7,9 @@ class TestMinimumSwaps(unittest.TestCase):
     def test_minimum_swaps(self):
 
         tests = [
-          {'title': 'Sample input 0', 'input': [4, 3, 1, 2], 'answer': 3},
-          {'title': 'Sample input 1', 'input': [2, 3, 4, 1, 5], 'answer': 3},
-          {'title': 'Sample input 2', 'input': [1, 3, 5, 2, 4, 6, 7], 'answer': 3},
+            {'title': 'Sample input 0', 'input': [4, 3, 1, 2], 'answer': 3},
+            {'title': 'Sample input 1', 'input': [2, 3, 4, 1, 5], 'answer': 3},
+            {'title': 'Sample input 2', 'input': [1, 3, 5, 2, 4, 6, 7], 'answer': 3},
         ]
 
         for _, _tt in enumerate(tests):

src/hackerrank/interview_preparation_kit/arrays/new_year_chaos_test.py

@@ -8,15 +8,15 @@ def test_minimum_bribes(self):
 
         tests = [
             {'title': "Test Case 0-0",
-                'input':  [2, 1, 5, 3, 4], 'answer': 3},
+                'input': [2, 1, 5, 3, 4], 'answer': 3},
             {'title': "Test Case 0-1",
-                'input':  [2, 5, 1, 3, 4], 'answer': TOO_CHAOTIC_ERROR},
+                'input': [2, 5, 1, 3, 4], 'answer': TOO_CHAOTIC_ERROR},
             {'title': "Test Case 1-1",
-                'input':  [5, 1, 2, 3, 7, 8, 6, 4], 'answer': TOO_CHAOTIC_ERROR},
+                'input': [5, 1, 2, 3, 7, 8, 6, 4], 'answer': TOO_CHAOTIC_ERROR},
             {'title': "Test Case 1-2",
-                'input':  [1, 2, 5, 3, 7, 8, 6, 4], 'answer': 7},
+                'input': [1, 2, 5, 3, 7, 8, 6, 4], 'answer': 7},
             {'title': "Test Case 2",
-                'input':  [1, 2, 5, 3, 4, 7, 8, 6], 'answer': 4},
+                'input': [1, 2, 5, 3, 4, 7, 8, 6], 'answer': 4},
         ]
 
         for _, _tt in enumerate(tests):

src/hackerrank/interview_preparation_kit/dictionaries_and_hashmaps/count_triplets_1.py

@@ -8,7 +8,7 @@ def count_triplets_brute_force(arr: list[int], r: int) -> int:
 
     for i in range(0, size - 2):
         for j in range(i + 1, size - 1):
-            for k in range(j+1, size):
+            for k in range(j + 1, size):
                 print(arr[i], arr[j], arr[k])
 
                 if r * arr[i] == arr[j] and r * arr[j] == arr[k]:
@@ -23,8 +23,8 @@ def count_triplets(arr, r):
     triplets = 0
 
     for i in arr:
-        j = i//r
-        k = i*r
+        j = i // r
+        k = i * r
         a[i] -= 1
         if b[j] and a[k] and i % r == 0:
             triplets += b[j] * a[k]

src/hackerrank/interview_preparation_kit/dynamic_programming/max_array_sum.py

@@ -18,7 +18,7 @@ def max_array_sum(arr_input: list[int]):
     arr[1] = t_max
 
     for i in range(2, n):
-        t_max = max(arr[i-2] + arr[i], t_max)  # Max uptill now
+        t_max = max(arr[i - 2] + arr[i], t_max)  # Max uptill now
         t_max = max(arr[i], t_max)  # Max in special case where
         # arr[i] + previous max is still less than arr[i]
         # update our inplace array with max for future calculations

src/hackerrank/interview_preparation_kit/graphs/roads_and_libraries.py

@@ -9,7 +9,7 @@ class RoadsAndLibraries:
 
     def __init__(self, n: int, cities: list[list[int]]):
 
-        self._paths = [-1 for _ in range(n+1)]
+        self._paths = [-1 for _ in range(n + 1)]
 
         for path in cities:
             a, b = path[0], path[1]

src/hackerrank/interview_preparation_kit/greedy_algorithms/angry_children_test.py

@@ -11,7 +11,7 @@
     {
         'title': 'Sample Test case 1',
         'k': 4,
-        'arr': [1, 2, 3,  4, 10, 20, 30, 40, 100, 200],
+        'arr': [1, 2, 3, 4, 10, 20, 30, 40, 100, 200],
         'answer': 3
     },
     {

src/hackerrank/interview_preparation_kit/linked_lists/insert_a_node_at_a_specific_position_in_a_linked_list_test.py

@@ -25,9 +25,9 @@ def test_insert_node_at_position(self):
         for _, _tt in enumerate(TEST_CASES):
 
             insert_node_at_position(
-                    _tt['llist'].head,
-                    _tt['data'],
-                    _tt['position'])
+                _tt['llist'].head,
+                _tt['data'],
+                _tt['position'])
 
             result = singly_linked_list_to_text(_tt['llist'].head, ' ')
 
@@ -47,9 +47,9 @@ def test_insert_node_at_position_edge_case(self):
         position = 0
 
         head = insert_node_at_position(
-                    llist.head,
-                    data,
-                    position)
+            llist.head,
+            data,
+            position)
 
         result = singly_linked_list_to_text(head, ' ')
 

src/hackerrank/interview_preparation_kit/linked_lists/insert_a_node_into_a_sorted_doubly_linked_list_test.py

@@ -42,8 +42,8 @@ def test_sorted_insert(self):
         for _, _tt in enumerate(TEST_CASES):
 
             llist = sorted_insert(
-                    _tt['llist'].head,
-                    _tt['data'])
+                _tt['llist'].head,
+                _tt['data'])
 
             result = double_linked_list_to_text(llist, ' ')
 
@@ -61,8 +61,8 @@ def test_sorted_insert_edge_case(self):
         data = 1
 
         head = sorted_insert(
-                    llist.head,
-                    data)
+            llist.head,
+            data)
 
         result = double_linked_list_to_text(head, ' ')
 

src/hackerrank/interview_preparation_kit/search/swap_nodes_algo.py

@@ -48,11 +48,11 @@ def callback_collect_plain(
 
 
 def traverse_in_order_collector(
-            root: Node,
-            collect: Dict[int, list[Node]],
-            level: int,
-            callback: Callable[[Node, Dict[int, list[Node]], int], None]
-        ) -> Dict[int, list[Node]]:
+    root: Node,
+    collect: Dict[int, list[Node]],
+    level: int,
+    callback: Callable[[Node, Dict[int, list[Node]], int], None]
+) -> Dict[int, list[Node]]:
 
     if root.left is not None:
         traverse_in_order_collector(root.left, collect, level + 1, callback)

src/hackerrank/interview_preparation_kit/sorting/ctci_bubble_sort_test.py

@@ -10,31 +10,31 @@
                   f'Last Element: {LAST_ELEMENT}{NL}'
 
 TEST_CASES = [
-                {
-                    'input': [6, 4, 1],
-                    'sorted': [1, 4, 6],
-                    'answer': ANSWER_TEMPLATE[:]
-                    .replace(NUM_SWAPS, '3')
-                    .replace(FIRST_ELEMENT, '1')
-                    .replace(LAST_ELEMENT, '6')
-                },
-                {
-                    'input': [3, 2, 1],
-                    'sorted': [1, 2, 3],
-                    'answer': ANSWER_TEMPLATE[:]
-                    .replace(NUM_SWAPS, '3')
-                    .replace(FIRST_ELEMENT, '1')
-                    .replace(LAST_ELEMENT, '3')
-                },
-                {
-                    'input': [1, 2, 3],
-                    'sorted': [1, 2, 3],
-                    'answer': ANSWER_TEMPLATE[:]
-                    .replace(NUM_SWAPS, '0')
-                    .replace(FIRST_ELEMENT, '1')
-                    .replace(LAST_ELEMENT, '3')
-                }
-            ]
+    {
+        'input': [6, 4, 1],
+        'sorted': [1, 4, 6],
+        'answer': ANSWER_TEMPLATE[:]
+        .replace(NUM_SWAPS, '3')
+        .replace(FIRST_ELEMENT, '1')
+        .replace(LAST_ELEMENT, '6')
+    },
+    {
+        'input': [3, 2, 1],
+        'sorted': [1, 2, 3],
+        'answer': ANSWER_TEMPLATE[:]
+        .replace(NUM_SWAPS, '3')
+        .replace(FIRST_ELEMENT, '1')
+        .replace(LAST_ELEMENT, '3')
+    },
+    {
+        'input': [1, 2, 3],
+        'sorted': [1, 2, 3],
+        'answer': ANSWER_TEMPLATE[:]
+        .replace(NUM_SWAPS, '0')
+        .replace(FIRST_ELEMENT, '1')
+        .replace(LAST_ELEMENT, '3')
+    }
+]
 
 
 class TestBubleSort(unittest.TestCase):

src/hackerrank/interview_preparation_kit/sorting/ctci_comparator_sorting_test.py

@@ -7,12 +7,12 @@ class TestComparatorSorting(unittest.TestCase):
         {
             'title': 'Sample Test Case 0',
             'input': [
-                    SortablePlayer('amy', 100),
-                    SortablePlayer('david', 100),
-                    SortablePlayer('heraldo', 50),
-                    SortablePlayer('aakansha', 75),
-                    SortablePlayer('aleksa', 150)
-                ],
+                SortablePlayer('amy', 100),
+                SortablePlayer('david', 100),
+                SortablePlayer('heraldo', 50),
+                SortablePlayer('aakansha', 75),
+                SortablePlayer('aleksa', 150)
+            ],
             'answer': '\n'.join(['aleksa 150',
                                  'amy 100',
                                  'david 100',
@@ -22,22 +22,22 @@ class TestComparatorSorting(unittest.TestCase):
         {
             'title': 'Sample Test Case 6',
             'input': [
-                    SortablePlayer('smith', 20),
-                    SortablePlayer('jones', 15),
-                    SortablePlayer('jones', 20)
-                ],
+                SortablePlayer('smith', 20),
+                SortablePlayer('jones', 15),
+                SortablePlayer('jones', 20)
+            ],
             'answer': '\n'.join(['jones 20',
                                  'smith 20',
                                  'jones 15'])
         },
         {
             'title': 'Sample Test Case 7',
             'input': [
-                    SortablePlayer('davis', 15),
-                    SortablePlayer('davis', 20),
-                    SortablePlayer('davis', 10),
-                    SortablePlayer('edgehill', 15)
-                ],
+                SortablePlayer('davis', 15),
+                SortablePlayer('davis', 20),
+                SortablePlayer('davis', 10),
+                SortablePlayer('edgehill', 15)
+            ],
             'answer': '\n'.join(['davis 20',
                                  'davis 15',
                                  'edgehill 15',
@@ -46,9 +46,9 @@ class TestComparatorSorting(unittest.TestCase):
         {
             'title': 'Edge case: draw',
             'input': [
-                    SortablePlayer('kurt', 100),
-                    SortablePlayer('kurt', 100)
-                ],
+                SortablePlayer('kurt', 100),
+                SortablePlayer('kurt', 100)
+            ],
             'answer': '\n'.join(['kurt 100',
                                  'kurt 100'])
         },

src/hackerrank/projecteuler/euler001.py

@@ -8,7 +8,7 @@
 def sum_of_arithmetic_progression(n: int, d: int) -> int:
 
     # Number of terms
-    n = n//d
+    n = n // d
 
     return (n) * (1 + n) * d // 2
 
@@ -17,8 +17,8 @@ def sum_of_arithmetic_progression(n: int, d: int) -> int:
 def euler001(a, b, n) -> int:
 
     # Since, we need the sum of multiples less than N
-    n = n-1
-    lcm = (a*b)//math.gcd(a, b)
+    n = n - 1
+    lcm = (a * b) // math.gcd(a, b)
 
     return sum_of_arithmetic_progression(n, a) + \
         sum_of_arithmetic_progression(n, b) - \