Add files via upload

Author: ikokkari

bytearraydemo.py

@@ -9,11 +9,11 @@
 import zlib
 from hashlib import sha256
 
-s = "This will be turned into an array of bytes \U0001F603, man!"
+s = "Here is an example Unicode string \U0001F603, man!"
 
-print(f"Length of s is {len(s)} characters.")
+print(f"Length of original string is {len(s)} characters.")
 sb = s.encode('utf-8')
-print(f"Length of sb is {len(sb)} bytes.")
+print(f"Length of extracted byte array is {len(sb)} bytes.")
 s = sb.decode('utf-8')
 print(f"Decoding sb gives back the string:\n{repr(s)}.")
 
@@ -33,7 +33,9 @@
 print(f"Its SHA-256 checksum is:\n{chk.hexdigest()}")
 
 # Natural language contains so much redundancy and uses so few of
-# the available charactes and words that it compresses massively.
+# the available character and word combinations that usually it
+# compresses massively without any information loss.
+
 sbc = zlib.compress(sb)
 print(f"Compressed, it needs only {len(sbc)} bytes.")
 

functional.py

@@ -48,7 +48,7 @@ def rising_power(n, k):
 
 # Determine whether the sequence x, f(x), f(f(f(x))), ... becomes
 # periodic after some point. A computer science classic without
-# needing more than O(1) extra memory.
+# needing more than constant amount of extra memory.
 
 
 def is_eventually_periodic(f, x, giveup=1000):
@@ -123,6 +123,7 @@ def lookup_f(*args):
             res = f(*args)       # calculate the result
             results[args] = res  # and store it in dictionary
         return res
+
     # Alias the local variable so it can be seen from outside.
     lookup_f.results = results
     # Result is a function that can be called same as original.
@@ -151,14 +152,14 @@ def fib(n):
 # http://paulbourke.net/fractals/qseries/
 
 
+@memoize
 def hof_q(n):
     if n < 3:
         return 1
     else:
-        return hof_q(n - hof_q(n-1)) + hof_q(n - hof_q(n-2))
+        return hof_q(n - hof_q(n - 1)) + hof_q(n - hof_q(n - 2))
 
 
-hof_q = memoize(hof_q)
 print(f"HofQ(100) = {hof_q(100)}.")
 
 # We can also perform the memoization explicitly. Since the function
@@ -190,7 +191,7 @@ def hof_qt(n):
 def wine(barrel, age, year, pour=Fraction(1, 2)):
     # Imaginary "zero" barrel to represent incoming flow of new wine.
     if barrel == 0:
-        return 1 if age == 0 else 0
+        return Fraction(1) if age == 0 else 0
     # In the initial state, all barrels consist of new wine.
     elif year == 0:
         return 1 if age == 0 else 0
@@ -268,8 +269,8 @@ def collatz(n):
 def thue_morse(n, sign):
     global __tm_call_count
     __tm_call_count += 1
-    if n == 1:
-        return '0' if sign == 0 else '1'
+    if n < 2:
+        return f"{str(sign)}"
     else:
         return thue_morse(n - 1, sign) + thue_morse(n - 1, 1 - sign)
 

morse.py

@@ -3,23 +3,25 @@
 # The dictionary of Morse codes and the corresponding letters.
 
 codes = {
-    ".-": "a", "-...": "b", "-.-.": "c", "-..": "d",
-    ".": "e", "..-.": "f", "--.": "g", "....": "h",
-    "..": "i", ".---": "j", "-.-": "k", ".-..": "l",
-    "--": "m", "-.": "n", "---": "o", ".--.": "p",
-    "--.-": "q", ".-.": "r", "...": "s", "-": "t",
-    "..-": "u", "...-": "v", ".--": "w", "-..-": "x",
-    "-.--": "y", "--..": "z"
+    '.-': 'a', '-...': 'b', '-.-.': 'c', '-..': 'd',
+    '.': 'e', '..-.': 'f', '--.': 'g', '....': 'h',
+    '..': 'i', '.---': 'j', '-.-': 'k', '.-..': 'l',
+    '--': 'm', '-.': 'n', '---': 'o', '.--.': 'p',
+    '--.-': 'q', '.-.': 'r', '...': 's', '-': 't',
+    '..-': 'u', '...-': 'v', '.--': 'w', '-..-': 'x',
+    '-.--': 'y', '--..': 'z'
     }
 
-# Morse code is not what is known as "prefix code" so that
+# Morse code is not what is known as 'prefix code' so that
 # no encoding of some character would be a prefix of the
 # encoding of some other character. This makes the decoding
 # ambiguous unless the Morse operator takes a noticeable
 # short pause between the individual letters.
 
 # Construct a reverse dictionary from an existing dictionary
-# with this handy dictionary comprehension.
+# with this handy dictionary comprehension. If multiple keys
+# of the original map to the same value, only the last pair
+# of value: key is stored in the reverse dictionary.
 
 codes_r = {codes[v]: v for v in codes}
 
@@ -29,8 +31,8 @@
 # individual letters. Unknown characters are simply skipped
 # in this encoding.
 
-def encode_morse(text, sep=""):
-    return sep.join((codes_r.get(c, "") for c in text.lower()))
+def encode_morse(text, sep=''):
+    return sep.join((codes_r.get(c, '') for c in text.lower()))
 
 
 # A generator function that yields all possible ways to
@@ -40,8 +42,8 @@ def encode_morse(text, sep=""):
 # the rest of the message.
 
 def decode_morse(message):
-    if message == "":
-        yield ""
+    if message == '':
+        yield ''
     else:
         for i in range(1, min(len(message) + 1, 5)):
             prefix = message[:i]
@@ -51,22 +53,22 @@ def decode_morse(message):
                     yield head + follow
 
 
-if __name__ == "__main__":
-    with open('words_sorted.txt', encoding="utf-8") as f:
+if __name__ == '__main__':
+    with open('words_sorted.txt', encoding='utf-8') as f:
         wordlist = [word.strip() for word in f if len(word) < 8]
-    print(f"Read a list of {len(wordlist)} words.")
+    print(f'Read a list of {len(wordlist)} words.')
 
     # Convert to set for a quick lookup of individual words.
     words = set(wordlist)
 
     for text in sample(wordlist, 20):
         enc = encode_morse(text)
-        print(f"The word {text!r} encodes in Morse to {enc!r}.")
-        print(f"The Morse code message {enc!r} decodes to words:")
+        print(f'The word {text!r} encodes in Morse to {enc!r}.')
+        print(f'The Morse code message {enc!r} decodes to words:')
         dec = [word for word in decode_morse(enc) if word in words]
         for word in dec:
             print(f"{word!r} split as {encode_morse(word, ' ')}")
-        print("")
+        print('')
 
-# Exercise for the reader: find the word whose encoding in Morse
-# can be decoded to largest possible number of different words.
+# Exercise for the reader: find the largest group of words that
+# all encode to the exact same series of Morse dots and dashes.

recursion.py

@@ -6,14 +6,21 @@
 # Many problems can be solved surprisingly easily by first
 # solving a smaller version of that problem, whose result is
 # then productively used in solving the original problem. The
-# classic textbook first example of recursion is factorial.
+# classic textbook first example of recursion is factorial
+# whose formula n! = 1 * 2 * ... * (n-1) * n is self-similar.
 
 
-def factorial(n):
+@functools.lru_cache()
+def factorial(n, verbose=False):
+    if verbose:
+        print(f"enter with n = {n}")
     if n < 2:
-        return 1                      # base case
+        result = 1                      # base case
     else:
-        return n * factorial(n - 1)   # recursive call
+        result = n * factorial(n - 1, verbose)   # linear recursive call
+    if verbose:
+        print(f"Returning {result} from {n}")
+    return result
 
 
 # Functional programming version, if only for humour value:
@@ -49,11 +56,11 @@ def factorial_it(n):
 
 def hanoi(src, tgt, n):
     if n < 1:
-        return
+        return None
     mid = 6 - src - tgt
-    hanoi(src, mid, n-1)
+    hanoi(src, mid, n - 1)
     print(f"Move top disk from peg {src} to peg {tgt}.")
-    hanoi(mid, tgt, n-1)
+    hanoi(mid, tgt, n - 1)
 
 
 # For computing high integer powers, binary power is more efficient
@@ -63,27 +70,28 @@ def binary_power(a, n, verbose=False):
     if verbose:
         print(f"Entering binary_power({n}).")
     if n < 0:
-        raise ValueError("Binary power negative exponent not allowed.")
+        raise ValueError(f"Negative exponent {n} not allowed.")
     elif n == 0:
         result = 1
     elif n % 2 == 0:
         result = binary_power(a * a, n // 2, verbose)
     else:
-        result = a * binary_power(a * a, (n-1) // 2, verbose)
+        result = a * binary_power(a * a, (n - 1) // 2, verbose)
     if verbose:
         print(f"Exiting binary_power({n}) with {result}.")
     return result
 
 
 # Flattening a list that can contain other lists as elements is a
 # classic list programming exercise. This being Python, the correct
-# "duck typing" spirit of checking of something is a list is to
-# check if it is iterable, that is, for our purposes it behaves
-# like a list.
+# "duck typing" spirit of checking of something is an iterable
+# sequence is to check if it allows creation of iterator objects
+# with the magic method __iter__, that is, for our purposes it acts
+# like a sequence.
 
-def flatten(li):
+def flatten(items):
     result = []
-    for x in li:
+    for x in items:
         if hasattr(x, '__iter__'):  # is x an iterable?
             result.extend(flatten(x))
         else:
@@ -104,10 +112,12 @@ def subset_sum(items, goal):
     if len(items) == 0 or goal < 0:
         return None
     last = items.pop()
-    answer = subset_sum(items, goal-last)
+    # Take the last element into chosen subset
+    answer = subset_sum(items, goal - last)
     if answer is not None:
         answer.append(last)
     else:
+        # Try not taking last element into subset
         answer = subset_sum(items, goal)
     items.append(last)
     return answer
@@ -167,7 +177,7 @@ def generate_tour(cx, cy):
 
 def ackermann(m, n):
     if m == 0:
-        return n+1
+        return n + 1
     elif m > 0 and n == 0:
         return ackermann(m - 1, 1)
     else:

reservoir.py

@@ -1,7 +1,7 @@
 from random import randint
 
 
-# Randomly choose k elements from given iterator.
+# Randomly choose k elements from given iterable.
 
 def reservoir(items, k):
     buffer = []
@@ -13,13 +13,12 @@ def reservoir(items, k):
             if idx < k:  # The new element hits the reservoir.
                 buffer[idx] = v  # displace some previous element
         count += 1
-    # Having read in every item, emit the reservoir elements.
-    yield from buffer
+    yield from buffer  # Emit the reservoir elements.
 
 
 if __name__ == "__main__":
     print("Here are 20 random non-short lines from 'War and Peace':")
-    with open('warandpeace.txt', encoding="utf-8") as wap:
+    with open('warandpeace.txt', encoding='utf-8') as wap:
         source = enumerate(reservoir((x.strip() for x in wap
                                       if len(x) > 60), 20))
         for (idx, line) in source:

wordfill.py

@@ -8,6 +8,17 @@
 # previous i - 1 horizontal and vertical words. If babbage is
 # set to True, the word square must have same rows and columns.
 
+# For example, the incomplete square
+#
+# hello
+# oasis
+# tt
+# ee
+# ln
+#
+# would be represented by parameter values n = 5, i = 2, vv = 0,
+# horiz = ['hello', 'oasis'] and vert = ['hotel', 'eaten'].
+
 def wordfill(n, i, horiz, vert, wordlist, vv, babbage=False):
     # Entire square is complete when rows 0, ..., n-1 are filled.
     if i == n:
@@ -23,7 +34,7 @@ def wordfill(n, i, horiz, vert, wordlist, vv, babbage=False):
             # Try using that word as the horizontal word.
             if not (word in horiz or word in vert):
                 horiz.append(word)
-                if babbage:
+                if babbage:  # Horizontal and vertical words equal
                     w = wordfill(n, i+1, horiz, horiz, wordlist, 0, True)
                 else:
                     w = wordfill(n, i+vv, vert, horiz, wordlist, 1-vv)
@@ -53,7 +64,7 @@ def wordfill(n, i, horiz, vert, wordlist, vv, babbage=False):
         i1 = bisect.bisect_left(wordlist, w1[0])
         i2 = bisect.bisect_right(wordlist, chr(ord(w1[0]) + 1))
         # Choose one of those words as the first vertical word.
-        w2 = wordlist[random.randint(i1, i2-1)]
+        w2 = wordlist[random.randint(i1, i2 - 1)]
         print(f"Trying out starting words {w1}, {w2}...", end=" ")
         found = False
         for sol in it.islice(wordfill(n, 1, [w1], [w2], wordlist, 0), 1):

wordproblems.py

@@ -137,6 +137,7 @@ def longest_substring_with_k_chars(text, k=2):
     # Extract the longest found substring as the answer.
     return text[maxpos:maxpos + max_]
 
+
 # Given a sorted list of words and the first word, construct a
 # word chain in which each word starts with the suffix of the
 # previous word with the first k characters removed, for example
@@ -201,8 +202,8 @@ def remain_words(words):
 def all_anagrams(words):
     codes = {}
     # The first 26 prime numbers, one for each letter from a to z.
-    primes = [2, 3, 5, 7, 11, 13, 17, 19, 23, 29, 31, 37, 41, 43, 47,
-              53, 59, 61, 67, 71, 73, 79, 83, 89, 97, 101]
+    primes = [2, 3, 5, 7, 11, 13, 17, 19, 23, 29, 31, 37, 41, 43,
+              47, 53, 59, 61, 67, 71, 73, 79, 83, 89, 97, 101]
     for word in words:
         m = 1
         for c in word: