condensed test code, other changes reflect comments on PR review

Author: miguelHx

Python/chapter01/1.1 - Is Unique/miguel_1.1_sol.py

@@ -11,36 +11,36 @@
 import unittest
 
 
-def check_is_unique_input(input_str):
+def _validate_input_str(input_str: str) -> None:
     """
     Does some input checking for the is_unique function and its variants
     Raises exceptions if input_str is empty or if input_str is not of type string
     :param input_str: a string that we are checking to make
     :return:
     """
-    if not isinstance(input_str, str):
-        raise TypeError("expected string as input")
     if input_str == "":
         raise ValueError("empty input string")
 
 
 def is_unique(input_str):
     """
     Determines if input_str has all unique characters.
-    input string MUST have at least 1 character. n>=1, where n is the number of characters in a string.
-    Hence, the domain is now defined. Any input not within the domain will not be considered. (n < 1)
+    For all characters in the input_str with n >= 1, where n is the number of characters in input_str,
+    there must be no duplicate characters.
+    In the worst case, the run time of this function will be O(n)
+    Space complexity will be O(n)
     An exception will be raised to handle faulty input.
     Given:		Expect:
     tacos		True
     swag		True
     bobby		False
     california	False
     orbit       True
-    e       true
+    e       True
     :param input_str: the string we want to check characters of
     :return: returns True if input_str has all unique characters, False otherwise
     """
-    check_is_unique_input(input_str)
+    _validate_input_str(input_str)
     chars_seen = set()
     for c in input_str:
         if c in chars_seen:
@@ -52,6 +52,8 @@ def is_unique(input_str):
 def is_unique_no_additional_data_structures(input_str):
     """
     Variant of is_unique.  Uses no additional data structures (besides the variables from the iterator)
+    However, the drawback is that the runtime is O((n*n-1)/2) = O(n^2), where n is the number of characters
+    in the input_str.
     Given:		Expect:
     tacos		True
     swag		True
@@ -62,39 +64,29 @@ def is_unique_no_additional_data_structures(input_str):
     :param input_str: the string we want to check characters of
     :return: returns True if input_str has all unique characters, False otherwise
     """
-    check_is_unique_input(input_str)
+    _validate_input_str(input_str)
     for i, c in enumerate(input_str):
         if c in input_str[i+1:]:
             return False
     return True
 
 
 class TestIsUniqueFunction(unittest.TestCase):
-    def test_is_unique(self):
-        self.assertFalse(is_unique("techqueria"))
-        self.assertTrue(is_unique("tacos"))
-        self.assertTrue(is_unique("swag"))
-        self.assertFalse(is_unique("bobby"))
-        self.assertFalse(is_unique("california"))
-        self.assertTrue(is_unique("orbit"))
-        self.assertTrue(is_unique("e"))
+    def _run_tests(self, f: callable([[str], None])) -> None:
+        for case in ["techqueria", "bobby", "california"]:
+            self.assertFalse(f(case), msg=case)
+        for case in ["tacos", "swag", "orbit", "e"]:
+            self.assertTrue(f(case), msg=case)
         with self.assertRaises(TypeError):
-            is_unique(8)
+            f(8)
         with self.assertRaises(ValueError):
-            is_unique("")
+            f("")
+
+    def test_is_unique(self):
+        self._run_tests(is_unique)
 
     def test_is_unique_no_additional_data_structures(self):
-        self.assertFalse(is_unique_no_additional_data_structures("techqueria"))
-        self.assertTrue(is_unique_no_additional_data_structures("tacos"))
-        self.assertTrue(is_unique_no_additional_data_structures("swag"))
-        self.assertFalse(is_unique_no_additional_data_structures("bobby"))
-        self.assertFalse(is_unique_no_additional_data_structures("california"))
-        self.assertTrue(is_unique_no_additional_data_structures("orbit"))
-        self.assertTrue(is_unique_no_additional_data_structures("e"))
-        with self.assertRaises(TypeError):
-            is_unique_no_additional_data_structures(8)
-        with self.assertRaises(ValueError):
-            is_unique_no_additional_data_structures("")
+        self._run_tests(is_unique_no_additional_data_structures)
 
 
 if __name__ == '__main__':