Develop

Makefile

@@ -105,6 +105,7 @@ coverage: test
 
 coverage/html: test
 	${RUNTIME_TOOL} -m coverage html
+	open htmlcov/index.html
 
 outdated:
 	${PACKAGE_TOOL} list --outdated

src/hackerrank/interview_preparation_kit/arrays/cruch_bruteforce.py

@@ -6,16 +6,15 @@
 LOGGER = logging.getLogger(__name__)
 
 
-def array_manipulation(n: int, queries: list[list[int]]) -> int:
-
-    result = [0] * (n + 1)
+def array_manipulation(n_operations: int, queries: list[list[int]]) -> int:
+    result = [0] * (n_operations + 1)
     maximum = 0
 
-    for [a, b, k] in queries:
+    for [a_start, b_end, k_value] in queries:
 
         LOGGER.debug("start -> %s", result)
-        for j in range(a, b + 1):
-            result[j] += k
+        for i in range(a_start, b_end + 1):
+            result[i] += k_value
             LOGGER.debug("result -> %s", result)
 
     for value in result:

src/hackerrank/interview_preparation_kit/arrays/cruch_optimized.py

@@ -9,17 +9,17 @@
 LOGGER = logging.getLogger(__name__)
 
 
-def array_manipulation_optimized(n: int, queries: list[list[int]]) -> int:
+def array_manipulation_optimized(n_operations: int, queries: list[list[int]]) -> int:
     # why adding 2?
     #   first slot to adjust 1-based index and
     #   last slot for storing accum_sum result
-    result = [0] * (n + 2)
+    result = [0] * (n_operations + 2)
     maximum = 0
 
-    for [a, b, k] in queries:
+    for [a_start, b_end, k_value] in queries:
         # Prefix
-        result[a] += k
-        result[b + 1] -= k
+        result[a_start] += k_value
+        result[b_end + 1] -= k_value
 
     accum_sum = 0
     for value in result:

src/hackerrank/interview_preparation_kit/arrays/ctci_array_left_rotation.py

@@ -15,11 +15,11 @@ def rot_left_one(group: list[int]) -> list[int]:
     return group
 
 
-def rot_left(group: list[int], d: int) -> list[int]:
+def rot_left(group: list[int], d_rotations: int) -> list[int]:
 
     output = group.copy()
     i = 1
-    while i <= d:
+    while i <= d_rotations:
         output = rot_left_one(output)
         i += 1
 

src/hackerrank/interview_preparation_kit/arrays/minimum_swaps_2.py

@@ -7,19 +7,19 @@
 
 
 def minimum_swaps(group: list[int]) -> int:
-    q = [i - 1 for i in group]
+    indexed_group = [i - 1 for i in group]
 
     swaps = 0
     index = 0
-    size = len(q)
+    size = len(indexed_group)
 
     while index < size:
-        if q[index] == index:
+        if indexed_group[index] == index:
             index += 1
         else:
-            temp = q[index]
-            q[index] = q[temp]
-            q[temp] = temp
+            temp = indexed_group[index]
+            indexed_group[index] = indexed_group[temp]
+            indexed_group[temp] = temp
             swaps += 1
 
     return swaps

src/hackerrank/interview_preparation_kit/dictionaries_and_hashmaps/count_triplets_1.py

@@ -1,3 +1,6 @@
+# @link Problem definition
+# [[docs/hackerrank/interview_preparation_kit/dictionaries_and_hashmaps/count_triplets_1.md]]
+
 from collections import Counter
 
 
@@ -18,16 +21,16 @@ def count_triplets_brute_force(arr: list[int], r: int) -> int:
 
 
 def count_triplets(arr, r):
-    a = Counter(arr)
-    b = Counter()
+    a_counter = Counter(arr)
+    b_counter = Counter()
     triplets = 0
 
     for i in arr:
         j = i // r
         k = i * r
-        a[i] -= 1
-        if b[j] and a[k] and i % r == 0:
-            triplets += b[j] * a[k]
-        b[i] += 1
+        a_counter[i] -= 1
+        if b_counter[j] and a_counter[k] and i % r == 0:
+            triplets += b_counter[j] * a_counter[k]
+        b_counter[i] += 1
 
     return triplets

src/hackerrank/interview_preparation_kit/dictionaries_and_hashmaps/ctci_ransom_note.py

@@ -1,31 +1,33 @@
 # @link Problem definition
 # [[docs/hackerrank/interview_preparation_kit/dictionaries_and_hashmaps/ctci-ransom-note.md]]
 
-from typing import Dict
+from typing import Dict, List
 
 __YES__ = 'Yes'
 __NO__ = 'No'
 
 
-def check_magazine_compute(magazine: str, note: str) -> bool:
+def check_magazine_compute(magazine: List[str], note: List[str]) -> bool:
     dictionary: Dict[str, int] = {}
 
-    for x in magazine:
+    word: str
 
-        if x in dictionary:
-            dictionary[x] += 1
+    for word in magazine:
+
+        if word in dictionary:
+            dictionary[word] += 1
         else:
-            dictionary[x] = 1
+            dictionary[word] = 1
 
-    for x in note:
+    for word in note:
 
-        if x in dictionary and dictionary[x] > 0:
-            dictionary[x] -= 1
+        if word in dictionary and dictionary[word] > 0:
+            dictionary[word] -= 1
         else:
             return False
 
     return True
 
 
-def check_magazine(magazine: str, note: str) -> str:
+def check_magazine(magazine: List[str], note: List[str]) -> str:
     return __YES__ if check_magazine_compute(magazine, note) else __NO__

src/hackerrank/interview_preparation_kit/dictionaries_and_hashmaps/ctci_ransom_note_test.py

@@ -24,9 +24,9 @@
 ]
 
 
-class TestSherlockAndAnagrams(unittest.TestCase):
+class TestCheckMagazine(unittest.TestCase):
 
-    def test_sherlock_and_anagrams(self):
+    def test_check_magazine(self):
 
         for _, _tt in enumerate(TEST_CASES):
 

src/hackerrank/interview_preparation_kit/dictionaries_and_hashmaps/frequency_queries_test.py

@@ -20,7 +20,7 @@
 ]
 
 
-class Test(unittest.TestCase):
+class TestFreqQuery(unittest.TestCase):
 
     def test_freq_query(self):
 

src/hackerrank/interview_preparation_kit/dictionaries_and_hashmaps/sherlock_and_anagrams.py

@@ -4,15 +4,15 @@
 import math
 
 
-def sherlock_and_anagrams(s: str) -> int:
+def sherlock_and_anagrams(s_word: str) -> int:
 
     candidates = {}
-    size = len(s)
+    size = len(s_word)
 
     # Calculate all substrings
     for i in range(0, size):
         for j in range(0, size - i):
-            substr = s[i:size - j]
+            substr = s_word[i:size - j]
             print(f'i: {i}, {size} size - j: {size - j} | substr: {substr}')
 
             # Add substrings to a candidate list.

src/hackerrank/interview_preparation_kit/dictionaries_and_hashmaps/two_strings_test.py

@@ -24,9 +24,9 @@
 ]
 
 
-class TestSherlockAndAnagrams(unittest.TestCase):
+class TestTwoStrings(unittest.TestCase):
 
-    def test_sherlock_and_anagrams(self):
+    def test_two_strings(self):
 
         for _, _tt in enumerate(TEST_CASES):
 

src/hackerrank/interview_preparation_kit/graphs/roads_and_libraries.py

@@ -7,38 +7,42 @@ class RoadsAndLibraries:
     _paths = []
     _unions = 0
 
-    def __init__(self, n: int, cities: list[list[int]]):
+    def __init__(self, q_paths: int, cities: list[list[int]]):
 
-        self._paths = [-1 for _ in range(n + 1)]
+        self._paths = [-1 for _ in range(q_paths + 1)]
 
         for path in cities:
-            a, b = path[0], path[1]
-            if self.unite(a, b):
+            city_a, city_b = path[0], path[1]
+            if self.unite(city_a, city_b):
                 self._unions += 1
 
     def find(self, a: int):
         return a if self._paths[a] < 0 else self.find(self._paths[a])
 
-    def unite(self, a: int, b: int) -> bool:
-        a = self.find(a)
-        b = self.find(b)
-        if a == b:
+    def unite(self, _point_a: int, _point_b: int) -> bool:
+        point_a = self.find(_point_a)
+        point_b = self.find(_point_b)
+        if point_a == point_b:
             return False
-        if self._paths[a] > self._paths[b]:
-            a, b = b, a
-        self._paths[a] += self._paths[b]
-        self._paths[b] = a
+        if self._paths[point_a] > self._paths[point_b]:
+            point_a, point_b = point_b, point_a
+        self._paths[point_a] += self._paths[point_b]
+        self._paths[point_b] = point_a
         return True
 
     def get_unions(self) -> int:
         return self._unions
 
 
-def roads_and_libraries(n: int, c_lib: int, c_road: int, cities: list[list[int]]) -> int:
+def roads_and_libraries(
+        q_paths: int,
+        c_lib: int,
+        c_road: int,
+        cities: list[list[int]]) -> int:
 
-    ral = RoadsAndLibraries(n, cities)
+    ral = RoadsAndLibraries(q_paths, cities)
     unions = ral.get_unions()
 
-    ans1 = c_lib * n
-    ans2 = c_road * unions + c_lib * (n - unions)
+    ans1 = c_lib * q_paths
+    ans2 = c_road * unions + c_lib * (q_paths - unions)
     return min(ans1, ans2)

src/hackerrank/interview_preparation_kit/greedy_algorithms/luck_balance.py

@@ -3,7 +3,7 @@
 # pylint: enable=line-too-long
 
 # pylint: disable=too-few-public-methods
-class Competition:
+class Contest:
     luck = 0
     important = 0
 
@@ -17,32 +17,33 @@ def __getitem__(self, item):
 
 def luck_balance(k, contests: list) -> int:
 
-    important_competitions: list[Competition] = []
-    nonimportant_competitions: list[Competition] = []
+    important_contests: list[Contest] = []
+    nonimportant_contests: list[Contest] = []
 
-    for x in contests:
-        luck = x[0]
-        important = x[1]
+    for contest in contests:
+        luck = contest[0]
+        important = contest[1]
 
         if important == 1:
-            important_competitions.append(Competition(luck=luck, important=important))
+            important_contests.append(Contest(luck=luck, important=important))
         else:
-            nonimportant_competitions.append(Competition(luck=luck, important=important))
+            nonimportant_contests.append(Contest(luck=luck, important=important))
 
-    important_competitions = sorted(
-        important_competitions,
+    important_contests = sorted(
+        important_contests,
         key=lambda contest: (-contest['important'], -contest['luck'])
     )
 
-    total = 0
-    size = len(important_competitions)
+    total: int = 0
+    size: int = len(important_contests)
+
     for i in range(0, min(k, size)):
-        total += important_competitions[i].luck
+        total += important_contests[i].luck
 
     for i in range(min(k, size), size):
-        total -= important_competitions[i].luck
+        total -= important_contests[i].luck
 
-    for x in nonimportant_competitions:
-        total += x.luck
+    for contest in nonimportant_contests:
+        total += contest.luck
 
     return total

src/hackerrank/interview_preparation_kit/linked_lists/ctci_linked_list_cycle.py

@@ -8,17 +8,13 @@
 def has_cycle(head: SinglyLinkedListNode) -> bool:
     llindex: list[SinglyLinkedListNode] = []
 
-    result = False
-    node = head
-    resume = True
+    node: SinglyLinkedListNode | None = head
 
-    while node and resume:
+    while node is not None:
         if node in llindex:
-            resume = False
-            result = True
-            return result
+            return True
 
         llindex.append(node)
         node = node.next
 
-    return result
+    return False