initial code from Chapter 1

Author: davecom

Chapter1/calculating_pi.py

@@ -0,0 +1,14 @@
+def calculate_pi(n_terms: int) -> float:
+    numerator: float = 4.0
+    denominator: float = 1.0
+    operation: float = 1.0
+    pi: float = 0.0
+    for _ in range(n_terms):
+        pi += operation * (numerator / denominator)
+        denominator += 2.0
+        operation *= -1.0
+    return pi
+
+
+if __name__ == "__main__":
+    print(calculate_pi(1000000))

Chapter1/fib1.py

@@ -0,0 +1,6 @@
+def fib1(n: int) -> int:
+    return fib1(n - 1) + fib1(n - 2)
+
+
+if __name__ == "__main__":
+    print(fib1(5))

Chapter1/fib2.py

@@ -0,0 +1,8 @@
+def fib2(n: int) -> int:
+    if n < 2:  # base case
+        return n
+    return fib2(n - 2) + fib2(n - 1)  # recursive case
+
+if __name__ == "__main__":
+    print(fib2(5))
+    print(fib2(10))

Chapter1/fib3.py

@@ -0,0 +1,15 @@
+from typing import Dict
+memo: Dict[int, int] = {0: 0, 1: 1}  # our old base cases
+
+
+def fib3(n: int) -> int:
+    if n in memo:  # our new base cases
+        return memo[n]
+    else:
+        memo[n] = fib3(n - 1) + fib3(n - 2)  # memoization
+    return memo[n]
+
+
+if __name__ == "__main__":
+    print(fib3(5))
+    print(fib3(50))

Chapter1/fib4.py

@@ -0,0 +1,13 @@
+from functools import lru_cache
+
+
+@lru_cache(maxsize=None)
+def fib4(n: int) -> int:  # same definition as fib2()
+    if n < 2:  # base case
+        return n
+    return fib4(n - 2) + fib4(n - 1)  # recursive case
+
+
+if __name__ == "__main__":
+    print(fib4(5))
+    print(fib4(50))

Chapter1/fib5.py

@@ -0,0 +1,13 @@
+def fib5(n: int) -> int:
+    if n == 0: return n  # special case
+    last: int = 0  # initially set to fib(0)
+    next: int = 1  # initially set to fib(1)
+    for _ in range(1, n):
+        last, next = next, last + next
+    return next
+
+
+if __name__ == "__main__":
+    print(fib5(2))
+    print(fib5(50))
+

Chapter1/fib6.py

@@ -0,0 +1,13 @@
+def fib6(n: int) -> int:
+    yield 0  # special case
+    if n > 0: yield 1  # special case
+    last: int = 0  # initially set to fib(0)
+    next: int = 1  # initially set to fib(1)
+    for _ in range(1, n):
+        last, next = next, last + next
+        yield next  # main generation step
+
+
+if __name__ == "__main__":
+    for i in fib6(50):
+        print(i)

Chapter1/hanoi.py

@@ -0,0 +1,41 @@
+from typing import TypeVar, Generic, List
+T = TypeVar('T')
+
+
+class Stack(Generic[T]):
+
+    def __init__(self):
+        self._container: List[T] = []
+
+    def push(self, item: T) -> None:
+        self._container.append(item)
+
+    def pop(self) -> T:
+        return self._container.pop()
+
+    def __repr__(self):
+        return repr(self._container)
+
+
+num_discs: int = 3
+tower_a: Stack[int] = Stack()
+tower_b: Stack[int] = Stack()
+tower_c: Stack[int] = Stack()
+for i in range(1, num_discs + 1):
+    tower_a.push(i)
+
+
+def hanoi(begin: Stack[int], end: Stack[int], temp: Stack[int], n: int) -> None:
+    if n == 1:
+        end.push(begin.pop())
+    else:
+        hanoi(begin, temp, end, n - 1)
+        hanoi(begin, end, temp, 1)
+        hanoi(temp, end, begin, n - 1)
+
+
+if __name__ == "__main__":
+    hanoi(tower_a, tower_c, tower_b, num_discs)
+    print(tower_a)
+    print(tower_b)
+    print(tower_c)

Chapter1/trivial_compression.py

@@ -0,0 +1,47 @@
+class CompressedGene:
+    def __init__(self, gene: str):
+        self._compress(gene)
+
+    def _compress(self, gene: str):
+        self.bit_string: int = 1  # start with sentinel
+        for nucleotide in gene.upper():
+            self.bit_string <<= 2  # shift left two bits
+            if nucleotide == "A":  # change last two bits to 00
+                self.bit_string |= 0b00
+            elif nucleotide == "C":  # change last two bits to 01
+                self.bit_string |= 0b01
+            elif nucleotide == "G":  # change last two bits to 10
+                self.bit_string |= 0b10
+            elif nucleotide == "T":  # change last two bits to 11
+                self.bit_string |= 0b11
+            else:
+                raise ValueError("Invalid Nucleotide:{}".format(nucleotide))
+
+    def decompress(self) -> str:
+        gene: str = ""
+        for i in range(0, self.bit_string.bit_length() - 1, 2):  # - 1 to exclude sentinel
+            bits: int = self.bit_string >> i & 0b11  # get just 2 relevant bits
+            if bits == 0b00:  # A
+                gene += "A"
+            elif bits == 0b01:  # C
+                gene += "C"
+            elif bits == 0b10:  # G
+                gene += "G"
+            elif bits == 0b11:  # T
+                gene += "T"
+            else:
+                raise ValueError("Invalid bits:{}".format(bits))
+        return gene[::-1]  # [::-1] reverses string by slicing backwards
+
+    def __str__(self) -> str:  # string representation for pretty printing
+        return self.decompress()
+
+
+if __name__ == "__main__":
+    from sys import getsizeof
+    original: str = "TAGGGATTAACCGTTATATATATATAGCCATGGATCGATTATATAGGGATTAACCGTTATATATATATAGCCATGGATCGATTATA" * 100
+    print("original is {} bytes".format(getsizeof(original)))
+    compressed: CompressedGene = CompressedGene(original)  # compress
+    print("compressed is {} bytes".format(getsizeof(compressed.bit_string)))
+    print(compressed)  # decompress
+    print("original and decompressed are the same: {}".format(original == compressed.decompress()))

Chapter1/unbreakable_encryption.py

@@ -0,0 +1,28 @@
+from secrets import token_bytes
+
+
+def random_key(length: int) -> int:
+    # generate length random bytes
+    tb: bytes = token_bytes(length)
+    # convert those bytes into a bit string and return it
+    return int.from_bytes(tb, "big")
+
+
+def encrypt(original: str) -> (int, int):
+    original_bytes: bytes = original.encode()
+    dummy: int = random_key(len(original_bytes))
+    original_key: int = int.from_bytes(original_bytes, "big")
+    encrypted: int = original_key ^ dummy  # XOR
+    return dummy, encrypted
+
+
+def decrypt(key1: int, key2: int) -> str:
+    decrypted: int = key1 ^ key2  # XOR
+    temp: bytes = int.to_bytes(decrypted, key1.bit_length() // 8, "big")
+    return temp.decode()
+
+
+if __name__ == "__main__":
+    key1, key2 = encrypt("One Time Pad!")
+    result: str = decrypt(key1, key2)
+    print(result)