Add files via upload

Minor style edits to bunch of source files.

Author: ikokkari

cardproblems.py

@@ -1,6 +1,10 @@
-from random import choice
+from random import Random
 from itertools import combinations
 
+# When using random numbers, hardcode the seed to make results reproducible.
+
+rng = Random(12345)
+
 # Define the suits and ranks that a deck of playing cards is made of.
 
 suits = ['clubs', 'diamonds', 'hearts', 'spades']
@@ -14,13 +18,13 @@ def deal_hand(n, taken=None):
     """Deal a random hand with n cards, without replacement."""
     result, taken = [], taken if taken else []
     while len(result) < n:
-        c = choice(deck)
+        c = rng.choice(deck)
         if c not in result and c not in taken:
             result.append(c)
     return result
 
 # If we don't care about taken, this could be one-liner:
-# return random.sample(deck, n)
+# return rng.sample(deck, n)
 
 
 def gin_count_deadwood(hand):
@@ -41,17 +45,17 @@ def blackjack_count_value(hand):
     for (rank, suit) in hand:
         v = ranks[rank]
         if v == 14:  # Treat every ace as 11 to begin with
-            total, soft = total + 11, soft + 1
+            total, soft = total+11, soft+1
         else:
             total += min(10, v)  # All face cards are treated as tens
         if total > 21:
-            if soft > 0:  # Saved by the soft ace
-                soft, total = soft - 1, total - 10
+            if soft:  # Saved by the soft ace
+                soft, total = soft-1, total-10
             else:
                 return 'bust'
     if total == 21 and len(hand) == 2:
         return 'blackjack'
-    return f"{'soft' if soft > 0 else 'hard'} {total}"
+    return f"{'soft' if soft else 'hard'} {total}"
 
 
 def poker_has_flush(hand):
@@ -116,10 +120,10 @@ def poker_has_straight(hand):
             return True  # AKQJT
         return all(rank in hand_ranks for rank in [2, 3, 4, 5])  # A2345
     else:
-        return max_rank - min_rank == 4
+        return max_rank-min_rank == 4
 
 
-# Straight flushes complicate the hand rankings a little bit.
+# Straight flushes complicate the hand rankings a bit.
 
 
 def poker_flush(hand):
@@ -167,7 +171,7 @@ def bridge_score(suit, level, vul, dbl, made):
     score, bonus = 0, 0
 
     # Add up the values of individual tricks.
-    for trick in range(1, made + 1):
+    for trick in range(1, made+1):
         # Raw points for this trick.
         if suit == 'clubs' or suit == 'diamonds':
             pts = 20

comprehensions.py

@@ -58,7 +58,7 @@
 
 # Squares of the first googol integers.
 
-h = (x * x for x in range(10 ** 100))
+h = (x*x for x in range(10 ** 100))
 
 # Notice how we didn't run out of memory. Many functions that operate
 # on iterators are smart enough to stop once they know the answer, so
@@ -85,10 +85,10 @@
 print(list(five))  # ['hello']
 
 # The Python functions all and any can be used to check if any or
-# all elements of a sequence, produced either with comprehension
-# or not, have some desired property. (Note that for empty sequence,
-# all is trivially true, and any is trivially false, regardless of
-# the condition used.)
+# all elements of a sequence, produced either with a comprehension
+# or something else, have some desired property. (Note that for empty
+# sequence, all is trivially true, and any is trivially false,
+# regardless of the condition used.)
 
 print(f"Is the number 29 a prime number? {not any(g1)}")
 print(f"Is the number 45 a prime number? {not any (g2)}")
@@ -100,20 +100,18 @@
 # An inner comprehension can be nested inside the evaluation of an outer
 # comprehension, to produce a sequence whose elements are sequences.
 
-u1 = [[x for x in range(n + 1)] for n in range(10)]
+u1 = [[x for x in range(n+1)] for n in range(10)]
 print(u1)
 
 # This technique allows us to partition a sequence into another sequence
 # of its consecutive elements, either overlapping or not.
 
 # Overlapping sequences of 3 consecutive elements by having the range
 # of n skip by default 1.
-u2 = [" ".join([words[x] for x in range(n, n + 3)])
-      for n in range(len(words) - 2)]
+u2 = [" ".join([words[x] for x in range(n, n+3)]) for n in range(len(words)-2)]
 print(u2)
 
 # Non-overlapping sequences of 3 consecutive elements by having the
 # range of n skip by 3.
-u3 = [" ".join([words[x] for x in range(n, n + 3)])
-      for n in range(0, len(words) - 2, 3)]
+u3 = [" ".join([words[x] for x in range(n, n+3)]) for n in range(0, len(words)-2, 3)]
 print(u3)

conditions.py

@@ -72,12 +72,17 @@ def is_leap_year_with_logic(y):
     return y % 4 == 0 and (y % 100 != 0 or y % 400 == 0)
 
 
+# Sneak preview of for-loops to iterate through the elements of the given
+# sequence. Verify that all three functions for leap year testing give the
+# same answer to all years ranging between those mentioned in the famous
+# song "In the year 2525" by Zager & Evans.
+
 def test_leap_year():
     for y in range(2525, 9596):
         a1 = is_leap_year(y)
         a2 = is_leap_year_another_way(y)
         a3 = is_leap_year_with_logic(y)
-        # Chaining comparison operators works also for equality.
+        # Chaining comparison operators works for equality just as well.
         if not (a1 == a2 == a3):  # a1 != a2 or a2 != a3:
-            return False  # Tear it down and start again.
-    return True           # I am pleased where man has been.
+            return False  # "Tear it down and start again."
+    return True           # "I am pleased where man has been."

countries.py

@@ -14,9 +14,7 @@
     total_pop += pop
 
 print('\nThe total population in each continent:')
-for continent in sorted(continental_pops,
-                        key=lambda c: continental_pops[c],
-                        reverse=True):
+for continent in sorted(continental_pops, key=lambda c: continental_pops[c], reverse=True):
     print(f"{continent} has a total of {continental_pops[continent]} people.")
 print(f'That gives a total of {total_pop} people on Earth.')
 
@@ -26,9 +24,7 @@
         hazard_table[hazard] = hazard_table.get(hazard, 0) + 1
 
 print('\nHere are the natural hazards found around the world.')
-for hazard in sorted(hazard_table,
-                     key=lambda h: (hazard_table[h], h),
-                     reverse=True):
+for hazard in sorted(hazard_table, key=lambda h: (hazard_table[h], h), reverse=True):
     title = hazard[0].upper() + hazard[1:]
     haz_count = hazard_table[hazard]
     print(f"{title} is a hazard in {haz_count} countries.")

defdemo.py

@@ -1,6 +1,6 @@
 from itertools import accumulate
 from math import log
-import random
+from random import Random
 
 # When we are building complex programs, or just a library of
 # useful code for other programmers to use as part of their
@@ -9,6 +9,11 @@
 # expects, followed by a code block telling what you do with
 # those parameters.
 
+# When using random numbers, hardcode the seed to make results reproducible.
+
+rng = Random(12345)
+
+
 # Factorial of n is the product of positive integers up to n.
 
 
@@ -17,7 +22,7 @@ def factorial(n):
     n -- The positive integer whose factorial is computed.
     """
     total = 1
-    for i in range(2, n + 1):
+    for i in range(2, n+1):
         total *= i
     return total
 
@@ -28,9 +33,9 @@ def factorial(n):
 # had been extended to have the factorial function:
 
 
-print(factorial(5))
-print(factorial(10))
-print(factorial(100))
+print(f"Factorial of 5 equals {factorial(5)}")
+print(f"Factorial of 20 equals {factorial(20)}")
+print(f"Factorial of 100 equals {factorial(100)}")
 
 # docstring is automatically placed in object under name __doc__
 print(factorial.__doc__)
@@ -43,12 +48,11 @@ def factorial(n):
 # assigned to point some place else.
 
 f = factorial    # copy a reference to the function object
-factorial_30 = f(30)   # make an actual function call
-print(factorial_30)    # 265252859812191058636308480000000
+print(f"Factorial of 30 equals {f(30)}")
 
 # All right, that out of the way, let's write some more functions that
 # operate on lists. First, find the largest element in the list. We do
-# this by iterating over the elements of the list
+# this first by explicitly iterating over the elements of the list.
 
 
 def maximum(seq):
@@ -115,7 +119,7 @@ def select_upsteps(seq):
 def leading_digit_list(n):
     prod = 1  # The current factorial
     digits = [0] * 10  # Create a list full of zeros
-    for i in range(1, n + 1):
+    for i in range(1, n+1):
         lead = int(str(prod)[0])  # Extract highest order digit
         digits[lead] += 1
         prod = prod * i  # Next factorial, from the current one
@@ -188,7 +192,7 @@ def roll_dice(rolls, faces=6):
     """
     total = 0
     for x in range(rolls):
-        total += random.randint(1, faces)
+        total += rng.randint(1, faces)
     return total
 
 

dissociated.py

@@ -1,12 +1,12 @@
-import random
+from random import Random
 from itertools import islice
 
 
 # Read through the text and build a dictionary that, for each found
 # pattern up to length n, gives the string of letters that follow that
 # pattern in the original text.
 
-def build_table(text, n=3, mlen=100):
+def build_table(text, n=3, max_len=100):
     result = {}
     for i in range(len(text) - n - 1):
         # The n-character string starting at position i.
@@ -16,23 +16,25 @@ def build_table(text, n=3, mlen=100):
         # Update the dictionary for each suffix of the current pattern.
         for j in range(n):
             follow = result.get(pattern[j:], "")
-            # Store only the first mlen occurrences of each pattern.
-            if len(follow) < mlen:
+            # Store only the first max_len occurrences of each pattern.
+            if len(follow) < max_len:
                 result[pattern[j:]] = follow + next_char
     return result
 
 
 # Aided by such table, generate random text one character at the time.
 
-def dissociated_press(table, start, maxpat=3):
+def dissociated_press(table, start, maxpat=3, rng=None):
+    if not rng:
+        rng = Random(12345)
     yield from start
     pattern = start[-maxpat:]
     while pattern not in table:
         pattern = pattern[1:]
     while True:
         follow = table[pattern]
         # Choose a random continuation for pattern and result.
-        c = random.choice(follow)
+        c = rng.choice(follow)
         yield c
         # Update the pattern also, shortening if necessary.
         pattern += c

generators.py

@@ -1,4 +1,4 @@
-import random
+from random import Random
 from fractions import Fraction
 
 # For the Aronson sequence below
@@ -8,8 +8,7 @@
 # The itertools module defines tons of handy functions to perform
 # computations on existing iterators, to be combined arbitrarily.
 
-from itertools import takewhile, islice, permutations,\
-     combinations, combinations_with_replacement
+from itertools import takewhile, islice, permutations, combinations, combinations_with_replacement
 
 # The "double-ended queue" or "deque" allows efficient push
 # and pop operations from both ends of the queue, whereas a
@@ -73,7 +72,7 @@ def collatz(start):
             start = 3 * start + 1
 
 
-# A generator that produces random integers with an ever increasing
+# A generator that produces random integers with an ever-increasing
 # scale. Handy for generating random test cases in tester.py that
 # produce test cases from all scales so that the first test cases
 # are guaranteed to be small. The scale determines how wide range
@@ -85,7 +84,7 @@ def collatz(start):
 
 def scale_random(seed, scale, skip):
     # The seed value determines the future random sequence.
-    rng = random.Random(seed)
+    rng = Random(seed)
     curr, count, orig = 1, 0, scale
     while True:
         curr += rng.randint(1, scale)
@@ -130,18 +129,18 @@ def theons_ladder(n=2, a=1, b=1):
         # Let the Fraction class simplify these numbers.
         a, b = f.numerator, f.denominator
         # Original Theon's ladder was just n = 2.
-        a, b = a + n * b, a + b
+        a, b = a + n * b, a+b
 
 
 # The next technique comes handy sometimes. Iterate through all integer
 # pairs of the form (a, b) where a and b are nonnegative integers so
 # that every such pair is visited exactly once.
 
 def all_pairs():
-    s = 0  # In each antidiagonal of the infinite 2D grid, a + b == s.
+    s = 0  # In each anti-diagonal of the infinite 2D grid, a+b == s.
     while True:
         for a in range(0, s + 1):
-            yield a, s - a
+            yield a, s-a
         s += 1
 
 # That one is handy when you need to loop through the infinite
@@ -166,7 +165,7 @@ def kolakoski(n=2):
     while True:
         v = q.popleft()
         yield v
-        prev = prev + 1 if prev < n else 1
+        prev = prev+1 if prev < n else 1
         for i in range(v):
             q.append(prev)
 
@@ -177,7 +176,7 @@ def aronson(letter='t'):
     n, tees, curr = 1, [], f'Letter {letter} is in positions '
     while True:
         yield from curr
-        tees.extend([i + n for (i, c) in enumerate(curr) if c == letter])
+        tees.extend([i+n for (i, c) in enumerate(curr) if c == letter])
         n += len(curr)
         curr, tees = int_to_english(tees[0]) + ', ', tees[1:]
 
@@ -213,7 +212,7 @@ def __demo():
     print("Collatz sequence starting from 12345 is:")
     print(list(every_kth(stutter(collatz(12345), 3), 3)))
 
-    # Take primes until they become greater than thousand.
+    # Take primes until they become greater than one thousand.
     print("Here is every seventh prime number up to one thousand:")
     print(list(takewhile((lambda x: x <= 1000), every_kth(primes(), 7))))
 

listproblems.py

@@ -1,4 +1,3 @@
-from math import sqrt
 from fractions import Fraction
 import heapq
 
@@ -43,8 +42,8 @@ def partition_in_place(s, pred):
     # Elements from position i to j, inclusive, can be anything.
     # Anything to left of i is acceptable, anything to the right
     # of j is unacceptable. When i == j, all is well.
-    i, j = 0, len(s) - 1
-    # Each round, one of the indices takes a step towards other.
+    i, j = 0, len(s)-1
+    # Each round, one of the indices takes a step towards the other.
     while i < j:
         # If s[i1] satisfies the predicate, leave it be...
         if pred(s[i]):