Add complexity measures for chapter 1, and a readme

Author: StBogdan

chapter_1/p1_1.py

@@ -1,5 +1,14 @@
 from collections import Counter
 
+# Method: Character map
+# Time: O(n)
+# Space: O(n)
+
+# Follow-up
+# Method: Sort and compare
+# Time: O(n*log(n))
+# Space: O(n)
+
 
 def all_uniqs(input_str: str):
     ctr = Counter(input_str)
@@ -24,4 +33,5 @@ def all_uniqs_no_datastruct(x: str):
     inputs = ["", "aaasodkc", "abbccdcss", "aaa", "b", "bdes"]
 
     for x in inputs:
-        print(f"Input {x} result: {all_uniqs(x)} same as {all_uniqs_no_datastruct(x)}")
+        print(
+            f"Input {x} result: {all_uniqs(x)} same as {all_uniqs_no_datastruct(x)}")

chapter_1/p1_2.py

@@ -1,5 +1,9 @@
 from collections import Counter
 
+# Method: Sort and compare
+# Time: O(n*log(n))
+# Space: O(n)
+
 
 def check_perm(a: str, b: str):
     sa = sorted(a)

chapter_1/p1_3.py

@@ -1,15 +1,19 @@
 from typing import List
 
+# Method: Count spaces, move into place from the end
+# Time: O(n)
+# Space: O(1)
+
 
 def urlize(a: List[chr], true_len):
     ei = true_len - 1
 
-    nr_s = 0
+    nr_spaces = 0
     for i in range(true_len):
         if a[i] == " ":
-            nr_s += 1
+            nr_spaces += 1
 
-    ei = true_len - 1 - (nr_s//3) * 2
+    ei = true_len - 1 - (nr_spaces//3) * 2
     # print(f"Turns out the string starts at {ei}")
     end_i = true_len-1
     while ei >= 0:
@@ -26,7 +30,9 @@ def urlize(a: List[chr], true_len):
     return "".join(a)
 
 
-def get_prob_input(str_w_spaces: str):
+def get_prob_input(str_w_spaces: str) -> str:
+    """Add the necessary buffer at the end, for a normal str
+    """
     spaces = str_w_spaces.count(" ")
     return str_w_spaces + " " * (spaces * 2), len(str_w_spaces) + spaces*2
 
@@ -41,4 +47,3 @@ def get_prob_input(str_w_spaces: str):
 
     a, fn = get_prob_input(" a c    a    c")
     print(f"Input is |{a}|, result |{urlize(list(a), fn)}| ")
-

chapter_1/p1_4.py

@@ -1,29 +1,37 @@
 import string
 from collections import Counter
 
+# Method: Map and check for odds
+# Time: O(n)
+# Space: O(n)
+
+# Method: Character bit-map, check set bits
+# Time: O(n)
+# Space: O(1) (limited by alphabet)
+
 
 def is_palindrom_perm(word: str) -> bool:
-    clean_w = proc(word)
+    clean_w = pre_process(word)
     ctr = Counter(clean_w)
     odd_c = sum(x % 2 for x in ctr.values())
     return not odd_c > 1
 
 
 def is_palindrome_perm_better(word: str) -> bool:
     bs = {c: 0b0 for c in string.ascii_lowercase}
-    for c in proc(word):
+    for c in pre_process(word):
         bs[c] ^= 0b1  # Flip by xor with one
     return not sum(x for x in bs.values()) > 1
 
 
-def proc(x: str) -> str:
+def pre_process(x: str) -> str:
     # x.translate(string.maketrans("","",string.punctuation))
     letter_iter = filter(lambda c: c.isalpha(), x.strip())
     return "".join(map(lambda x: x.lower(), letter_iter))
 
 
 if __name__ == "__main__":
-    print(proc("a...!>!>!a<<>  <!!!aaa"))
+    print(pre_process("a...!>!>!a<<>  <!!!aaa"))
 
     def printex(ex): return print(
         f"For exampple: {ex} ==> {is_palindrom_perm(ex)} \

chapter_1/p1_5.py

@@ -1,3 +1,7 @@
+# Method: Char by char check, count differences
+# Time: O(min(n,m)), where n,m the lenghts of the input strings
+# Space: O(1)
+
 
 def is_edit(a: str, b: str) -> bool:
     la = len(a)
@@ -17,28 +21,28 @@ def check_edit(a: str, b: str) -> bool:
     lb = len(b)
     i = 0
     j = 0
-    mm = 0
+    mismatches = 0
 
     while i < la and j < lb:
         if a[i] == b[j]:
             i += 1
         else:
-            mm += 1
+            mismatches += 1
         j += 1
 
-        if mm > 1:
+        if mismatches > 1:
             return False
 
     return abs(i-j) <= 1
 
 
 def check_subst(a, b) -> bool:
-    mm = 0
+    mistmatches = 0
 
     for i in range(len(a)):
         if a[i] != b[i]:
-            mm += 1
-        if mm > 1:
+            mistmatches += 1
+        if mistmatches > 1:
             return False
 
     return True

chapter_1/p1_6.py

@@ -1,18 +1,23 @@
-def basic_compr(a: str) -> str:
-    cl = 0
-    n = len(a)
+# Method: Build new, counting occurences
+# Time: O(n)
+# Space: O(n)
+
+
+def basic_compr(input_str: str) -> str:
+    len_compres = 0
+    len_orig = len(input_str)
     res = []
 
     prev = None
     prev_count = 0
-    for c in a:
+    for c in input_str:
         if c != prev:
             if prev:
                 res.append(prev)
                 res.append(str(prev_count))
-                cl += 1 + len(str(prev_count))
-                if cl > n:
-                    return a
+                len_compres += 1 + len(str(prev_count))
+                if len_compres > len_orig:
+                    return input_str
             prev = c
             prev_count = 1
         else:
@@ -21,9 +26,9 @@ def basic_compr(a: str) -> str:
     res.append(prev)
     res.append(str(prev_count))
 
-    cl += 1 + len(str(prev_count))
+    len_compres += 1 + len(str(prev_count))
 
-    return a if cl > n else "".join(res)
+    return input_str if len_compres > len_orig else "".join(res)
 
 
 if __name__ == "__main__":

chapter_1/p1_7.py

@@ -1,5 +1,9 @@
 from typing import List
 
+# Method: Recursive edge-walking
+# Time: O(n*m), where n,m the dimensions of the matrix
+# Space: O(1)
+
 
 def rotate(arr: List[List[int]]) -> List[List[int]]:
     rot_help(arr, 0, len(arr[0])-1, 0, len(arr)-1)

chapter_1/p1_8.py

@@ -1,47 +1,51 @@
 from typing import List
 
+# Method: Individual cell checks, with handling of first line and col
+# Time: O(n*m)
+# Space: O(1)
+
 
 def zero_m(matric: List[List[int]]):
-    n, m = len(matric), len(matric[0])
+    rows, cols = len(matric), len(matric[0])
     fcol0 = False
     frow0 = False
 
-    for i in range(n):
-        if matric[i][0] == 0:
+    for r in range(rows):
+        if matric[r][0] == 0:
             fcol0 = True
             break
 
-    for j in range(m):
-        if matric[0][j] == 0:
+    for c in range(cols):
+        if matric[0][c] == 0:
             frow0 = True
             break
 
-    for i in range(n):
-        for j in range(m):
-            if matric[i][j] == 0:
-                matric[i][0] = 0
-                matric[0][j] = 0
+    for r in range(rows):
+        for c in range(cols):
+            if matric[r][c] == 0:
+                matric[r][0] = 0
+                matric[0][c] = 0
 
     print(f"Gonna zero now, first row {frow0} and first col {fcol0}")
     mrint(matric)
 
-    for i in range(1, n):
-        if matric[i][0] == 0:
-            for j in range(m):
-                matric[i][j] = 0
+    for r in range(1, rows):
+        if matric[r][0] == 0:
+            for c in range(cols):
+                matric[r][c] = 0
 
-    for j in range(1, m):
-        if matric[0][j] == 0:
-            for i in range(n):
-                matric[i][j] = 0
+    for c in range(1, cols):
+        if matric[0][c] == 0:
+            for r in range(rows):
+                matric[r][c] = 0
 
     if fcol0:
-        for i in range(n):
-            matric[i][0] = 0
+        for r in range(rows):
+            matric[r][0] = 0
 
     if frow0:
-        for j in range(m):
-            matric[0][j] = 0
+        for c in range(cols):
+            matric[0][c] = 0
 
     return matric
 

chapter_1/p1_9.py

@@ -1,3 +1,8 @@
+# Method: Attach to itself
+# Time: O(n) (create new string, potentially substring check)
+# Space: O(n) (store the new big string)
+
+
 def checkrot(s1: str, s2: str):
     s22 = s2 + s2
     return isSubstr(s1, s22) and len(s1) == len(s2)

chapter_1/readme.md

@@ -0,0 +1,15 @@
+# Chapter 1: Arrays and Strings
+
+The complexity table is for a quick lookup, more details in the actual file (e.g. explaining the symbols used)
+
+| Nr. 	| Title 	| Solution 	| Time 	| Space 	| Notes 	|
+|:---:	|:-----:	|:--------:	|:----:	|:-----:	|:-----:	|
+| 1.1 	| Is unique             | [Python](./p1_1.py) | O(n) 	| O(n) 	| 	|
+| 1.2 	| Check Permutation     | [Python](./p1_2.py) | O(n*log(n)) 	| O(n) 	| 	|
+| 1.3 	| URLify                | [Python](./p1_3.py) | O(n) 	| O(1) 	| 	|
+| 1.4 	| Palindrome Permutation        | [Python](./p1_4py) | O(n) 	| O(1) 	| 	|
+| 1.5 	| One Away                      | [Python](./p1_5.py) | O(min(n,m)) 	| O(1) 	| 	|
+| 1.6 	| String Compression            | [Python](./p1_6.py) | O(n) 	| O(n) 	| 	|
+| 1.7 	| Rotate Matrix         | [Python](./p1_7.py) | O(n*m) 	| O(1) 	| 	|
+| 1.8 	| Zero Matrix           | [Python](./p1_8.py) | O(n*m) 	| O(1) 	| 	|
+| 1.9 	| String Rotation       | [Python](./p1_9.py) | O(n) 	| O(n) 	| 	|