Merge pull request #9 from nickolasteixeira/chapter1

Chapter1 solutions 1.5 - 1.9

Author: fvntr

Python/chapter01/1.5 - OneAway/Nick.py

@@ -0,0 +1,42 @@
+#!/usr/bin/python3
+import unittest
+
+
+def one_away(s1, s2):
+    '''Given two strings, write a function to check if
+    they are one edit (or zero edits) away.'''
+    if abs(len(s1) - len(s2)) > 1:
+        return False
+
+    str1 = s1 if len(s1) < len(s2) else s2
+    str2 = s2 if len(s1) < len(s2) else s1
+    idx1, idx2 = 0, 0
+    diff = False
+
+    while idx1 < len(str1) and idx2 < len(str2):
+        if str1[idx1] is not str2[idx2]:
+            if diff:
+                return False
+            diff = True
+
+            if len(str1) is len(str2):
+                idx1 += 1
+        else:
+            idx1 += 1
+        idx2 += 1
+
+    return True
+
+
+class Test(unittest.TestCase):
+    def test1(self):
+        s1 = "Tact Cat"
+        s2 = "TactCat"
+        s3 = "nick"
+        s4 = "jeff"
+        self.assertTrue(one_away(s1, s2))
+        self.assertFalse(one_away(s3, s4))
+
+
+if __name__ == '__main__':
+    unittest.main()

Python/chapter01/1.6 - String Compression/Nick.py

@@ -0,0 +1,49 @@
+#!/usr/bin/python3
+import unittest
+
+
+def string_compression(string):
+    '''Implement a method to perform basic string compression using the counts
+of repeated characters. For example, the string aabcccccaaa would become a2blc5a3. If the
+"compressed" string would not become smaller than the original string, your method should return
+the original string. You can assume the string has only uppercase and lowercase letters (a - z). '''
+    if not isinstance(string, str):
+        return False
+
+    new_str = ''
+    count, new_count = 0, 0
+    for idx in range(len(string) - 1):
+        count += 1
+        if string[idx] is not string[idx + 1]:
+            new_str += string[idx]
+            new_str += str(count)
+            count = 0
+        if idx is len(string) - 2:
+            if string[idx] is string[idx + 1]:
+                new_str += string[idx]
+                new_str += str(count + 1)
+            else:
+                new_str += string[idx + 1]
+                new_str += '1'
+
+    for letter in new_str:
+        if letter is '1':
+            new_count += 1
+
+    if len(string) // new_count is 1:
+        return string
+    return new_str
+
+
+class Test(unittest.TestCase):
+    def test1(self):
+        self.assertEqual(string_compression('aabcccccaaa'), 'a2b1c5a3')
+        self.assertEqual(
+            string_compression('bbaaaabcdeeefff'),
+            'b2a4b1c1d1e3f3')
+        self.assertEqual(string_compression('abcdef'), 'abcdef')
+        self.assertNotEqual(string_compression('abcdef'), 'a1b1c1d1e1f1')
+
+
+if __name__ == '__main__':
+    unittest.main()

Python/chapter01/1.7 - Rotate Matrix/Nick.py

@@ -0,0 +1,45 @@
+#!/usr/bin/python3
+import random
+from pprint import pprint
+
+def build_matrix(w, h, max=10):
+    '''function that builds a matrix with random numbers including 0'''
+    return [[random.randint(0, max) for _ in range(w)] for _ in range(h)]
+
+def rotate_matrix(matrix):
+    '''function that rotates a matrix clockwise'''
+    if (len(matrix) is 0 or len(matrix) is not len(matrix[0])): return False
+    matrix_length = len(matrix)
+    for layer in range(matrix_length//2):
+        first = layer
+        last = matrix_length - 1 - layer
+        for i in range(first, last):
+            offset = i - first
+            top = matrix[first][i]
+
+            ######################
+            #  a  ---------->  d #
+            #  ^               | #
+            #  |               | #
+            #  |               | #
+            #  |               v #
+            #  b <------------ c #
+            #######################
+
+            # top left inherits from bottom bottom left
+            matrix[first][i] = matrix[last - offset][first]
+
+            # bottom left becomes bottom right
+            matrix[last - offset][first] = matrix[last][last - offset]
+
+            # bottom right becomes top right
+            matrix[last][last - offset] = matrix[i][last]
+
+            # top right becomes top left
+            matrix[i][last] = top
+
+if __name__ =='__main__':
+    matrix = build_matrix(5, 5)
+    pprint(matrix)
+    rotate_matrix(matrix)
+    pprint(matrix)

Python/chapter01/1.8 - Zero Matrix/Nick.py

@@ -0,0 +1,35 @@
+#!/usr/bin/python3
+import random
+
+
+def build_matrix(w, h, max=10):
+    '''function that builds a matrix with random numbers including 0'''
+    return [[random.randint(0, max) for _ in range(w)] for _ in range(h)]
+
+
+def zero_matrix(matrix):
+    '''Write an algorithm such that if an element in an MxN matrix is 0, its entire row and
+column are set to 0.'''
+    row, column = [], []
+    zero_present = False
+
+    for idx1 in range(len(matrix)):
+        for idx2 in range(len(matrix[idx1])):
+            if matrix[idx1][idx2] is 0:
+                zero_present = True
+                row.append(idx1)
+                column.append(idx2)
+
+    if zero_present:
+        for idx1 in range(len(matrix)):
+            for idx2 in range(len(matrix[idx1])):
+                if idx1 in row:
+                    matrix[idx1][idx2] = 0
+                if idx2 in column:
+                    matrix[idx1][idx2] = 0
+
+if __name__ == '__main__':
+    matrix = build_matrix(4, 4)
+    print("Old Matrix => ", matrix)
+    zero_matrix(matrix)
+    print("New Matrix => ", matrix)

Python/chapter01/1.9 - String Rotation/Nick.py

@@ -0,0 +1,21 @@
+#!/usr/bin/python3
+import unittest
+
+def is_rotation(s1, s2):
+    '''Assumeyou have a method isSubstringwhich checks if oneword is a substring
+of another. Given two strings, sl and s2, write code to check if s2 is a rotation of sl using only one
+call to isSubstring (e.g., "waterbottle" is a rotation of"erbottlewat"). '''
+    if len(s1) is len(s2) and len(s1) > 0:
+        return s2 in s1 + s1
+    return False
+
+
+class Test(unittest.TestCase):
+    def test1(self):
+        self.assertTrue(is_rotation('waterbottle', 'erbottlewat'))
+        self.assertFalse(is_rotation('watermellon', 'watermellons'))
+        self.assertFalse(is_rotation('waterbottle', 'bottleaterw'))
+
+
+if __name__ == '__main__':
+    unittest.main()