Merge pull request #3 from techqueria/master

merge base repo changes

Author: miguelHx

Python/chapter01/1.3 - URLify/miguel_1.3_sol.py

@@ -0,0 +1,108 @@
+"""
+Python version 3.7.0
+1.3 - URLify
+Write a method to replace all spaces in a string with "%20".
+The following only applies to C/C++: "You may assume that the string has sufficient
+space at the end to hold the additional characters, and that you are given the "true" length of the string"
+(Note: If implementing in Java, please use a character array so that you can perform this operation in place)
+Since we are using python, no need to use true length.  I will have two functions, one with
+true_length and the other without.
+"""
+import unittest
+from typing import List
+
+
+def urlify(s: str) -> str:
+    """
+    Given a string, this function will return a new string
+    that replaces all of the spaces of the input string with '%20'.
+    :param s: the original string to 'urlify'
+    :return: string with each space from s replaced with '%20'
+    """
+    buf = ['\x00'] * (len(s) * 3)
+    for i, c in enumerate(s):
+        buf[i] = c
+
+    def _challenge(buf: List[str], original_length: int) -> None:
+        """
+        Your code here. Challenge rules:
+        * You can only reference |buf| and |original_length|, not |s|.
+        * You can only allocate O(1) additional memory
+        * You need to modify |buf| in-place so that the right answer is returned.
+        * You cannot modify any part of the wrapper function.
+        :param buf: buffer containing characters
+        :param original_length: original length of string
+        :return: None
+        """
+        space_count = 0
+        for j in range(original_length):
+            if buf[j] == ' ':
+                space_count += 1
+
+        chars_per_space = 2
+        idx = original_length + space_count * chars_per_space
+        for i in range(original_length-1, -1, -1):
+            if buf[i] == ' ':
+                buf[idx-1] = '0'
+                buf[idx-2] = '2'
+                buf[idx-3] = '%'
+                idx -= 3
+                continue
+            buf[idx-1] = buf[i]
+            idx -= 1
+    _challenge(buf, len(s))
+    return ''.join(buf).rstrip('\x00')
+
+
+def urlify_no_true_length(s: str) -> str:
+    """
+    This is the version of urlify without the true_length argument.
+    Given a string and it's "true" length, this function will return a new string
+    that replaces all of the spaces of the input string with '%20'.
+    Note that this will return a different result than the other urlify
+    if the other urlify's true length truncates the string with chars left over.
+    Precondition(s):
+    - length of s <= true_length
+    :param s: the original string to 'urlify'
+    :return: string with each space from s replaced with '%20'
+    """
+    output = []
+    for c in s:
+        if c == ' ':
+            output.append("%20")
+            continue
+        output.append(c)
+    return ''.join(output)
+
+
+class TestUrlifyFunction(unittest.TestCase):
+    def test_urlify(self):
+        cases = [
+            ("Mr John Smith", "Mr%20John%20Smith"),
+            ("Miguel Hernandez", "Miguel%20Hernandez"),
+            (" Techqueria", "%20Techqueria"),
+            ("a b c d e f g h", "a%20b%20c%20d%20e%20f%20g%20h"),
+            ("ihavenospaces", "ihavenospaces"),
+            ("nospaces", "nospaces"),
+            (" ", "%20")
+        ]
+        for s, expected in cases:
+            self.assertEqual(urlify(s), expected, msg=s)
+
+    def test_urlify_no_true_length(self):
+        cases = [
+            ("Mr John Smith", "Mr%20John%20Smith"),
+            ("Miguel Hernandez", "Miguel%20Hernandez"),
+            (" Techqueria ", "%20Techqueria%20"),
+            ("a b c d e f g h", "a%20b%20c%20d%20e%20f%20g%20h"),
+            ("a b c d e f g h ignore this", "a%20b%20c%20d%20e%20f%20g%20h%20ignore%20this"),
+            ("ihavenospaces", "ihavenospaces"),
+            ("nospacesIgnoreme", "nospacesIgnoreme"),
+            (" ", "%20")
+        ]
+        for s, expected in cases:
+            self.assertEqual(urlify_no_true_length(s), expected, msg=s)
+
+
+if __name__ == '__main__':
+    unittest.main()

Python/chapter01/1.4 - PalinPerm/Nick4.py

@@ -6,7 +6,7 @@
 '''
 
 import unittest
-
+import collections
 
 def palperm(string):
     '''
@@ -15,17 +15,30 @@ def palperm(string):
         string (str): a string to check for all palindrome permutations
     '''
     table = {}
-    count = 0
     for letter in string.lower().replace(" ", ""):
         table[letter] = table.get(letter, 0) + 1
 
+    count = 0
     for key in table:
-        if count > 1:
-            return False
         if table[key] % 2 == 1:
             count += 1
+        if count > 1:
+            return False
     return True
 
+def palperm2(string):
+    letter_frequencies = collections.defaultdict(int)
+    for letter in string.lower().replace(' ', ''):
+        letter_frequencies[letter] += 1
+    
+    odd_frequency_count = 0
+    for frequency in letter_frequencies.values():
+        if frequency % 2 == 0:
+            continue
+        odd_frequency_count += 1
+        if odd_frequency_count > 1:
+            return False
+    return True
 
 class Test(unittest.TestCase):
     def test1(self):
@@ -38,5 +51,15 @@ def test1(self):
         self.assertTrue(palperm(input_string3))
         self.assertTrue(palperm(input_string4))
 
+    def test2(self):
+        input_string ="Tact Coa"
+        input_string2 ="nick"
+        input_string3 ="saippuakivikauppias"
+        input_string4 = "iasppaukivikauppias"
+        self.assertTrue(palperm2(input_string))
+        self.assertFalse(palperm2(input_string2))
+        self.assertTrue(palperm2(input_string3))
+        self.assertTrue(palperm2(input_string4))
+
 if __name__ == '__main__':
     unittest.main()

Python/chapter01/1.4 - PalinPerm/miguel_1.4_sol.py

@@ -0,0 +1,115 @@
+"""
+Python version 3.7.0
+1.4 - Palindrome Permutation
+Given a string, write a function to check if it is a permutation of a palindrome.
+A palindrome is a word or phrase that is the same forwards and backwards.  A permutation is a
+rearrangement of letters.  The palindrome does not need to be limited to just dictionary words.
+"""
+import unittest
+import itertools as it
+import collections
+from typing import Callable
+
+
+def is_permutation_of_palindrome(s: str) -> bool:
+    """
+    Checks if a string is a palindrome by analyzing the frequencies of characters.
+    A palindrome is a word or phrase that is the same forwards and backwards.
+    When determining character frequencies, word will be put to lowercase
+    and spaces will not be counted
+    A palindrome also has the following property:
+    * at most one character appears an odd number of times
+    Runtime: O(n)
+    Space Complexity: O(n)
+    :param s: the string we check, 's' is a possible permutation of a palindrome
+    :return: true if s is a permutation of a palindrome, false otherwise
+    """
+    char_frequencies = collections.Counter(s.lower().replace(' ', ''))
+    num_odd_freq_chars = 0
+
+    for key, val in char_frequencies.items():
+        if val % 2 == 0:
+            continue
+        num_odd_freq_chars += 1
+        if num_odd_freq_chars > 1:
+            return False
+    return True
+
+
+def _is_palindrome(s: str) -> bool:
+    """
+    Checks if s is a palindrome by checking if the forward version is the same as the backward version.
+    A palindrome is a word or phrase that is the same forwards and backwards.
+    Whitespace will not be considered when determining palindrome.
+    This function is case insensitive.
+    Runtime:  O(n)
+    Space Complexity:  O(n)
+    :param s: the string we check, possible permutation of a palindrome
+    :return: true if s is a palindrome, false otherwise
+    """
+    s_no_spaces = s.replace(' ', '').lower()
+    reversed_s = s_no_spaces[::-1]
+    return s_no_spaces == reversed_s
+
+
+def is_permutation_of_palindrome_brute_force(s: str) -> bool:
+    """
+    Given a string, this function will return whether the string is a permutation of a palindrome.
+    A palindrome is a word or phrase that is the same forwards and backwards.
+    A permutation is a rearrangement of letters.
+    When evaluating whether a string is the same forwards and backwards, we will
+    omit whitespace.  For ex: "taco cat" would not equal "tac ocat" IF we expect a space at the 4th index for
+    the reversed version.  So, the space will not be taken into account only when determining palindrome.
+    Assuming ASCII
+    Runtime is O(n!)
+    Space complexity is O(n)
+    Given:      Expect:
+    Tact Coa        True (permutations: "taco cat", "atco cta")
+    :param s: the string that we want to check for perm of a palindrome
+    :return: True if s is a palindrome, False otherwise.
+    """
+    s_no_spaces = s.replace(' ', '')
+    for p in it.permutations(s_no_spaces):
+        if _is_palindrome(''.join(p)):
+            return True
+    return False
+
+
+class TestIsPermutationOfPalindromeFunction(unittest.TestCase):
+    def _run_tests(self, f: Callable[[str], bool]) -> None:
+        cases = [
+            ("Tact Coa", True),
+            ("car race", True),
+            ("ppilffli", True),
+            ("gwas", False),
+            ("sldkjflks", False),
+            (" ", True),
+            ("", True),
+            ("a", True)
+        ]
+        for s, expected in cases:
+            self.assertEqual(f(s), expected, msg=s)
+
+    def test_is_permutation_of_palindrome(self):
+        self._run_tests(is_permutation_of_palindrome_brute_force)
+        self._run_tests(is_permutation_of_palindrome)
+
+    def test_is_palindrome(self):
+        cases = [
+            ("Taco Cat", True),
+            ("race car", True),
+            ("flippilf", True),
+            ("swag", False),
+            ("miguel", False),
+            (" ", True),
+            ("", True),
+            ("a", True),
+            ("Tacoo Cat", True),
+            ("Tacooo Cat", True)
+        ]
+        for s, expected in cases:
+            self.assertEqual(_is_palindrome(s), expected, msg=s)
+
+
+if __name__ == '__main__':
+    unittest.main()