Add files via upload

Author: ikokkari

autogram.py

@@ -1,6 +1,6 @@
 from random import Random
 
-# Convert an integer into its English language name.
+__googol = 10 ** 100
 
 # http://lcn2.github.io/mersenne-english-name/tenpower/tenpower.html
 __pows = (("thousand", 3), ("million", 6), ("billion", 9),
@@ -21,41 +21,45 @@
           )
 
 # Dictionary comprehension, analogous to list comprehension.
-__pows = { p:n for (n, p) in __pows }
+__pows = {p: n for n, p in __pows}
+
 
-# Return the English name of a three-digit integer.
 def __int_to_eng(n):
-    if n < 20: # Numbers 0 to 19 with a simple lookup table.
+    """Return the English name of a three-digit positive number."""
+    assert 0 < n < 1000
+    if n < 20:  # Numbers 0 to 19 with a simple lookup table.
         return ["ERROR", "one", "two", "three", "four", "five",
                 "six", "seven", "eight", "nine", "ten", "eleven",
                 "twelve", "thirteen", "fourteen", "fifteen",
                 "sixteen", "seventeen", "eighteen", "nineteen"][n]
-    elif n < 100: # Numbers 20 to 99, tens again with a lookup table.
-        tens = ["", "", "twenty", "thirty", "forty", "fifty", 
+    elif n < 100:  # Numbers 20 to 99, again with a lookup table.
+        tens = ["ERROR", "ERROR", "twenty", "thirty", "forty", "fifty",
                 "sixty", "seventy", "eighty", "ninety"][n // 10]
-        return tens if n % 10 == 0 else f"{tens}-{__int_to_eng(n % 10)}" 
-    else: # Numbers 100 to 999
-        if n % 100 == 0:
-            return f"{__int_to_eng(n // 100)} hundred"            
-        else:
-            return f"{__int_to_eng(n // 100)} hundred and {__int_to_eng(n % 100)}"            
-               
-__googol = 10 ** 100
+        return tens if n % 10 == 0 else f"{tens}-{__int_to_eng(n % 10)}"
+    else:  # Numbers 100 to 999
+        name = f"{__int_to_eng(n//100)} hundred"
+        if n % 100 != 0:
+            name += f"and {__int_to_eng(n%100)}"
+        return name
+
 
-# Construct the English name of any integer.
 def int_to_english(n):
-    if n < 0: # Negative numbers
+    """Construct the English name of the given integer n."""
+    if n < 0:  # Negative numbers
         return "minus " + int_to_english(-n)
-    if n == 0: # Zero as a special case
+    if n == 0:  # Zero as a special case
         return "zero"
-    if n >= __googol: # huge numbers
+    if n >= __googol:  # Huge numbers
         first = int_to_english(n // __googol)
         rest = int_to_english(n % __googol)
-        return f"{first} googol" if rest == "zero" else f"{first} googol and {rest}"
+        name = f"{first} googol"
+        if rest != "zero":
+            name += "and {rest}"
+        return name
     # Otherwise, break the number into blocks of three and convert.
     result, p = [], 0
     while n > 0:
-        trip, n = n % 1000, n // 1000        
+        trip, n = n % 1000, n // 1000
         if trip > 0:
             if p == 0:
                 result.append(__int_to_eng(trip))
@@ -65,15 +69,16 @@ def int_to_english(n):
     return " ".join(reversed(result))
 
 # Find an autogram, a text that describes in English how many times
-# each letter appears inside it. As with many of the 109 lab problems, 
+# each letter appears inside it. As with many of the 109 lab problems,
 # this example was inspired by the works of the late great Martin
 # Gardner and his collected columns on recreational mathematics in
 # the Scientific American magazine.
-    
-def autogram_finder(text, rng, verbose=True, perturb = 20):
+
+
+def autogram_finder(text, rng, verbose=True, perturb=20):
     letters, rounds = "abcdefghijklmnopqrstuvwxyz", 0
     count, best = [rng.randint(2, 50) for c in letters], 0
-    
+
     while True:
         rounds += 1
         # Fill in text placeholders with names for each number.
@@ -85,14 +90,15 @@ def autogram_finder(text, rng, verbose=True, perturb = 20):
         lfill = filled.lower()
         actual = [lfill.count(c) for c in letters]
         # Find the letters whose counts are correct.
-        same = "".join([c for (i, c) in enumerate(letters) if count[i] == actual[i]])
+        same = "".join([c for (i, c) in enumerate(letters)
+                        if count[i] == actual[i]])
         # Replace the previous best solution, if this one is better.
         if len(same) > best:
             best = len(same)
             if verbose:
                 print(f"\n{filled}")
-                print(f"Actual: {', '.join([f'{l}:{c}' for (l, c) in zip(letters, actual)])}")
-                print(f"Matched {len(same)} letters '{same}' in {rounds} rounds.")
+                print(f"Actual: {', '.join([f'{l}:{c}' for l, c in zip(letters, actual)])}")
+                print(f"Matched {len(same)} letters '{same}'.")
             if best == 26:
                 return filled
         count = actual
@@ -108,15 +114,16 @@ def autogram_finder(text, rng, verbose=True, perturb = 20):
 # $c is the count for the character c, and $$ is the total
 # number of letters in the text. (That one makes the search
 # far more difficult.)
-    
-text = """This zesty, bookish and joyful quip was composed by
+
+
+__text = """This zesty, bookish and joyful quip was composed by
 Ilkka Kokkarinen to serve as an example for this course, and it
 contains $a a's, $b b's, $c c's, $d d's, $e e's, $f f's, $g g's,
 $h h's, $i i's, $j j's, $k k's, $l l's, $m m's, $n n's, $o o's,
 $p p's, $q q's, $r r's, $s s's, $t t's, $u u's, $v v's, $w w's,
 $x x's, $y y's and finally, to top it all off, $z z's."""
-text = text.replace("\n", " ")
-text = text.replace("\t", " ")
+__text = __text.replace("\n", " ")
+__text = __text.replace("\t", " ")
 
 # This zesty, bookish and joyful quip was composed by Ilkka
 # Kokkarinen to serve as an example for this course, and it
@@ -133,12 +140,12 @@ def autogram_finder(text, rng, verbose=True, perturb = 20):
     for x in [42, 3**7, 6**20, -(2**100), 9**200, 10**500]:
         print(f"{x} written in English is {int_to_english(x)}.")
     print("Here are integers 0-100 sorted in alphabetical order:")
-    print(sorted(range(0, 101), key = int_to_english))
+    print(sorted(range(0, 101), key=int_to_english))
     print("Here are integers 0-100 sorted in order of name lengths:")
-    print(sorted(range(0, 101), key = lambda x: (len(int_to_english(x)), x)))
+    print(sorted(range(0, 101), key=lambda x: (len(int_to_english(x)), x)))
     print("The numbers that do not contain the letter 'o':")
     print([x for x in range(1000) if 'o' not in int_to_english(x)])
-   
+
     # When using a randomized algorithm, it is good to used a fixed
     # seed to make the results repeatable.
-    autogram_finder(text, Random(9999), perturb = 0)
+    autogram_finder(__text, Random(12345), True, 20)

bytearraydemo.py

@@ -3,6 +3,9 @@
 # byte array can be processed with byte array operations such as
 # checksums and compressions, not caring where these bytes came from.
 
+import zlib
+from hashlib import sha256
+
 s = "This will be turned into an array of bytes \U0001F603."
 
 print(f"Length of s is {len(s)}.")
@@ -11,15 +14,12 @@
 s = sb.decode('utf-8')
 print(f"Decoding bytes gives the string {repr(s)}.")
 
-import zlib
-from hashlib import sha256
-
 print(f"Adler checksum of string s: {zlib.adler32(sb)}")
 print(f"CRC32 checksum of string s: {zlib.crc32(sb)}")
 
 with open('warandpeace.txt', encoding="utf-8") as wap:
     s = " ".join(list(wap))   # this will be a really long string
-print(f"'War and Peace' contains {len(s)} characters.") 
+print(f"'War and Peace' contains {len(s)} characters.")
 
 sb = s.encode('utf-8')
 print(f"Encoded as byte array using utf-8, this gives {len(sb)} bytes.")