From 9b05b2e7ae95cf2ae932d3fe97372ecdde4fedc3 Mon Sep 17 00:00:00 2001
From: Laurent Luce <laurentluce49@yahoo.com>
Date: Fri, 17 Jan 2020 13:53:14 -0500
Subject: [PATCH 01/16] Updated README following removal of some algos.

---
 README.md | 14 --------------
 1 file changed, 14 deletions(-)

diff --git a/README.md b/README.md
index b081e2d..99df38e 100644
--- a/README.md
+++ b/README.md
@@ -6,14 +6,6 @@ The purpose of this library is to help you with common algorithms like:
 
 A* path finding.
 
-Binary tree
-  - lookup.
-  - insert.
-  - delete.
-  - compare 2 trees.
-  - print tree.
-  - tree inorder generator.
-
 String Matching
   - Naive.
   - Rabin-Karp.
@@ -27,12 +19,6 @@ String
 Generators
   - Permutations.
 
-Lists
-  - Subset with highest sum.
-  - Find integer in sorted list.
-  - Merge sort.
-  - Quicksort.
-
 ### Installation
 Get the source and run
 

From a80c09336b9728eb29108d9e346a5d8547cb8631 Mon Sep 17 00:00:00 2001
From: Laurent Luce <laurentluce49@yahoo.com>
Date: Thu, 24 Dec 2020 17:40:55 -0500
Subject: [PATCH 02/16] Remove some algos.

---
 algorithms/binary_tree.py            | 166 ---------------------------
 algorithms/list.py                   | 122 --------------------
 algorithms/maze.py                   |   0
 algorithms/tests/test_binary_tree.py | 165 --------------------------
 algorithms/tests/test_list.py        |  62 ----------
 5 files changed, 515 deletions(-)
 delete mode 100644 algorithms/binary_tree.py
 delete mode 100644 algorithms/list.py
 delete mode 100644 algorithms/maze.py
 delete mode 100644 algorithms/tests/test_binary_tree.py
 delete mode 100644 algorithms/tests/test_list.py

diff --git a/algorithms/binary_tree.py b/algorithms/binary_tree.py
deleted file mode 100644
index 3e8c20b..0000000
--- a/algorithms/binary_tree.py
+++ /dev/null
@@ -1,166 +0,0 @@
-from __future__ import print_function
-
-
-class Node(object):
-    """Tree node: left and right child + data which can be any object
-
-    """
-    def __init__(self, data):
-        """Node constructor
-
-        @param data node data object
-        """
-        self.left = None
-        self.right = None
-        self.data = data
-
-    def insert(self, data):
-        """Insert new node with data
-
-        @param data node data object to insert
-        """
-        if self.data:
-            if data < self.data:
-                if self.left is None:
-                    self.left = Node(data)
-                else:
-                    self.left.insert(data)
-            elif data > self.data:
-                if self.right is None:
-                    self.right = Node(data)
-                else:
-                    self.right.insert(data)
-        else:
-            self.data = data
-
-    def lookup(self, data, parent=None):
-        """Lookup node containing data
-
-        @param data node data object to look up
-        @param parent node's parent
-        @returns node and node's parent if found or None, None
-        """
-        if data < self.data:
-            if self.left is None:
-                return None, None
-            return self.left.lookup(data, self)
-        elif data > self.data:
-            if self.right is None:
-                return None, None
-            return self.right.lookup(data, self)
-        else:
-            return self, parent
-
-    def delete(self, data):
-        """Delete node containing data
-
-        @param data node's content to delete
-        """
-        # get node containing data
-        node, parent = self.lookup(data)
-        if node is not None:
-            children_count = node.children_count()
-            if children_count == 0:
-                # if node has no children, just remove it
-                if parent:
-                    if parent.left is node:
-                        parent.left = None
-                    else:
-                        parent.right = None
-                else:
-                    self.data = None
-            elif children_count == 1:
-                # if node has 1 child
-                # replace node by its child
-                if node.left:
-                    n = node.left
-                else:
-                    n = node.right
-                if parent:
-                    if parent.left is node:
-                        parent.left = n
-                    else:
-                        parent.right = n
-                else:
-                    self.left = n.left
-                    self.right = n.right
-                    self.data = n.data
-            else:
-                # if node has 2 children
-                # find its successor
-                parent = node
-                successor = node.right
-                while successor.left:
-                    parent = successor
-                    successor = successor.left
-                # replace node data by its successor data
-                node.data = successor.data
-                # fix successor's parent node child
-                if parent.left == successor:
-                    parent.left = successor.right
-                else:
-                    parent.right = successor.right
-
-    def compare_trees(self, node):
-        """Compare 2 trees
-
-        @param node tree to compare
-        @returns True if the tree passed is identical to this tree
-        """
-        if node is None:
-            return False
-        if self.data != node.data:
-            return False
-        res = True
-        if self.left is None:
-            if node.left:
-                return False
-        else:
-            res = self.left.compare_trees(node.left)
-        if res is False:
-            return False
-        if self.right is None:
-            if node.right:
-                return False
-        else:
-            res = self.right.compare_trees(node.right)
-        return res
-
-    def print_tree(self):
-        """Print tree content inorder
-
-        """
-        if self.left:
-            self.left.print_tree()
-        print(self.data, end=" ")
-        if self.right:
-            self.right.print_tree()
-
-    def tree_data(self):
-        """Generator to get the tree nodes data
-
-        """
-        # we use a stack to traverse the tree in a non-recursive way
-        stack = []
-        node = self
-        while stack or node:
-            if node:
-                stack.append(node)
-                node = node.left
-            else:
-                # we are returning so we pop the node and we yield it
-                node = stack.pop()
-                yield node.data
-                node = node.right
-
-    def children_count(self):
-        """Return the number of children
-
-        @returns number of children: 0, 1, 2
-        """
-        cnt = 0
-        if self.left:
-            cnt += 1
-        if self.right:
-            cnt += 1
-        return cnt
diff --git a/algorithms/list.py b/algorithms/list.py
deleted file mode 100644
index 86fb40f..0000000
--- a/algorithms/list.py
+++ /dev/null
@@ -1,122 +0,0 @@
-def find_int(i, l):
-    """Find integer in a sorted list.
-
-    Example: 4 in [1, 3, 4, 6, 7, 9] -> 2
-    @param i integer to find.
-    @param l sorted list.
-    @returns index if found, None if not.
-    """
-    if l:
-        p_idx = len(l) / 2
-        p = l[p_idx]
-        if i == p:
-            return p_idx
-        elif len(l) == 1:
-            return
-        elif i < p:
-            res = find_int(i, l[:p_idx])
-            if res:
-                return res
-        elif i > p:
-            res = find_int(i, l[p_idx:])
-            if res:
-                return res + p_idx
-
-
-def find_max_sub(l):
-    """Find subset with higest sum.
-
-    Example: [-2, 3, -4, 5, 1, -5] -> (3,4), 6
-    @param l list
-    @returns subset bounds and highest sum
-    """
-    # max sum
-    max = l[0]
-    # current sum
-    m = 0
-    # max sum subset bounds
-    bounds = (0, 0)
-    # current subset start
-    s = 0
-    for i in range(len(l)):
-        m += l[i]
-        if m > max:
-            max = m
-            bounds = (s, i)
-        elif m < 0:
-            m = 0
-            s = i+1
-    return bounds, max
-
-
-def merge_sort(l):
-    """Sort list using merge sort.
-
-    Complexity: O(n log n)
-
-    @param l list to sort.
-    @returns sorted list.
-    """
-    def merge(l1, l2):
-        """Merge sorted lists l1 and l2.
-
-        [1, 2, 4], [1, 3, 4, 5] -> [1, 1, 2, 3, 4, 5]
-        @param l1 sorted list
-        @param l2 sorted list
-        @returns merge sorted list
-        """
-        res = []
-        i = 0
-        j = 0
-        while i < len(l1) and j < len(l2):
-            if l1[i] <= l2[j]:
-                res.append(l1[i])
-                i += 1
-            elif l2[j] < l1[i]:
-                res.append(l2[j])
-                j += 1
-
-        while i < len(l1):
-            res.append(l1[i])
-            i += 1
-
-        while j < len(l2):
-            res.append(l2[j])
-            j += 1
-
-        return res
-
-    length = len(l)
-    if length <= 1:
-        return l
-    mid = length / 2
-    h1 = merge_sort(l[:mid])
-    h2 = merge_sort(l[mid:])
-
-    return merge(h1, h2)
-
-
-def quicksort(l):
-    """Sort list using quick sort.
-
-    Complexity: O(n log n).  Worst: O(n2)
-
-    @param l list to sort.
-    @returns sorted list.
-    """
-    if len(l) <= 1:
-        return l
-
-    pivot = l[0]
-    less = []
-    equal = []
-    greater = []
-    for e in l:
-        if e < pivot:
-            less.append(e)
-        elif e == pivot:
-            equal.append(e)
-        else:
-            greater.append(e)
-
-    return quicksort(less) + equal + quicksort(greater)
diff --git a/algorithms/maze.py b/algorithms/maze.py
deleted file mode 100644
index e69de29..0000000
diff --git a/algorithms/tests/test_binary_tree.py b/algorithms/tests/test_binary_tree.py
deleted file mode 100644
index 0ec3397..0000000
--- a/algorithms/tests/test_binary_tree.py
+++ /dev/null
@@ -1,165 +0,0 @@
-import copy
-import unittest
-
-import algorithms.binary_tree as binary_tree
-
-
-class BinaryTreeTest(unittest.TestCase):
-
-    def setUp(self):
-        self.root_single_node = binary_tree.Node(None)
-        self.root = binary_tree.Node(10)
-        self.root.left = binary_tree.Node(5)
-        self.root.left.left = binary_tree.Node(3)
-        self.root.left.right = binary_tree.Node(7)
-        self.root.right = binary_tree.Node(15)
-        self.root.right.left = binary_tree.Node(12)
-        self.root.right.left.left = binary_tree.Node(11)
-        self.root.right.right = binary_tree.Node(20)
-        self.root_copy = copy.deepcopy(self.root)
-
-    def test_insert(self):
-        root = self.root_single_node
-
-        root.insert(10)
-        self.assertEqual(root.data, 10)
-
-        root.insert(5)
-        self.assertEqual(root.left.data, 5)
-
-        root.insert(15)
-        self.assertEqual(root.right.data, 15)
-
-        root.insert(8)
-        self.assertEqual(root.left.right.data, 8)
-
-        root.insert(2)
-        self.assertEqual(root.left.left.data, 2)
-
-        root.insert(12)
-        self.assertEqual(root.right.left.data, 12)
-
-        root.insert(17)
-        self.assertEqual(root.right.right.data, 17)
-
-    def test_lookup(self):
-        node, parent = self.root.lookup(0)
-        self.assertIsNone(parent)
-        self.assertIsNone(node)
-
-        node, parent = self.root.lookup(13)
-        self.assertIsNone(parent)
-        self.assertIsNone(node)
-
-        node, parent = self.root.lookup(7)
-        self.assertIs(node, self.root.left.right)
-        self.assertIs(parent, self.root.left)
-
-    def test_delete_root_no_child(self):
-        self.root_single_node.data = 7
-        self.root_single_node.delete(7)
-        self.assertIsNone(self.root_single_node.data)
-
-    def test_delete_root_one_child(self):
-        self.root_single_node.data = 7
-        self.root_single_node.insert(3)
-        self.root_single_node.delete(7)
-        self.assertEqual(self.root_single_node.data, 3)
-
-    def test_delete_one_child_left(self):
-        self.root.delete(12)
-        self.assertEqual(self.root.left.data, 5)
-        self.assertEqual(self.root.left.left.data, 3)
-        self.assertEqual(self.root.left.right.data, 7)
-        self.assertEqual(self.root.right.data, 15)
-        self.assertEqual(self.root.right.left.data, 11)
-        self.assertEqual(self.root.right.right.data, 20)
-
-    def test_delete_one_child_right(self):
-        self.root.insert(25)
-        self.root.delete(20)
-        self.assertEqual(self.root.left.data, 5)
-        self.assertEqual(self.root.left.left.data, 3)
-        self.assertEqual(self.root.left.right.data, 7)
-        self.assertEqual(self.root.right.data, 15)
-        self.assertEqual(self.root.right.left.data, 12)
-        self.assertEqual(self.root.right.left.left.data, 11)
-        self.assertEqual(self.root.right.right.data, 25)
-
-    def test_delete_right_leaf(self):
-        self.root.delete(7)
-        self.assertIsNone(self.root.left.right)
-        self.assertEqual(self.root.left.data, 5)
-        self.assertEqual(self.root.left.left.data, 3)
-        self.assertEqual(self.root.right.data, 15)
-        self.assertEqual(self.root.right.left.data, 12)
-        self.assertEqual(self.root.right.left.left.data, 11)
-        self.assertEqual(self.root.right.right.data, 20)
-
-    def test_delete_left_leaf(self):
-        self.root.delete(3)
-        self.assertIsNone(self.root.left.left)
-        self.assertEqual(self.root.left.data, 5)
-        self.assertEqual(self.root.left.right.data, 7)
-        self.assertEqual(self.root.right.data, 15)
-        self.assertEqual(self.root.right.left.data, 12)
-        self.assertEqual(self.root.right.left.left.data, 11)
-        self.assertEqual(self.root.right.right.data, 20)
-
-    def test_delete_right_node_two_childs(self):
-        self.root.delete(15)
-        self.assertEqual(self.root.left.data, 5)
-        self.assertEqual(self.root.left.left.data, 3)
-        self.assertEqual(self.root.left.right.data, 7)
-        self.assertEqual(self.root.right.data, 20)
-        self.assertEqual(self.root.right.left.data, 12)
-        self.assertEqual(self.root.right.left.left.data, 11)
-
-    def test_delete_left_node_two_childs(self):
-        self.root.delete(5)
-        self.assertEqual(self.root.left.data, 7)
-        self.assertEqual(self.root.left.left.data, 3)
-        self.assertEqual(self.root.right.data, 15)
-        self.assertEqual(self.root.right.left.data, 12)
-        self.assertEqual(self.root.right.left.left.data, 11)
-        self.assertEqual(self.root.right.right.data, 20)
-
-    def test_delete_root_two_childs(self):
-        self.root.delete(10)
-        self.assertEqual(self.root.left.data, 5)
-        self.assertEqual(self.root.left.left.data, 3)
-        self.assertEqual(self.root.left.right.data, 7)
-        self.assertEqual(self.root.data, 11)
-        self.assertEqual(self.root.right.data, 15)
-        self.assertEqual(self.root.right.left.data, 12)
-        self.assertEqual(self.root.right.right.data, 20)
-
-    def test_compare_trees_left_leaf_missing(self):
-        self.root_copy.delete(11)
-        self.assertFalse(self.root.compare_trees(self.root_copy))
-
-    def test_compare_trees_right_leaf_missing(self):
-        self.root_copy.delete(20)
-        self.assertFalse(self.root.compare_trees(self.root_copy))
-
-    def test_compare_trees_diff_value(self):
-        self.root_copy.left.data = 16
-        self.assertFalse(self.root.compare_trees(self.root_copy))
-
-    def test_compare_trees_extra_right_leaf(self):
-        self.root_copy.insert(25)
-        self.assertFalse(self.root.compare_trees(self.root_copy))
-
-    def test_compare_trees_extra_left_leaf(self):
-        self.root_copy.insert(18)
-        self.assertFalse(self.root.compare_trees(self.root_copy))
-
-    def test_print_tree(self):
-        self.root.print_tree()
-
-    def test_tree_data(self):
-        self.assertEqual([e for e in self.root.tree_data()],
-                         [3, 5, 7, 10, 11, 12, 15, 20])
-
-if __name__ == '__main__':
-    unittest.main()
diff --git a/algorithms/tests/test_list.py b/algorithms/tests/test_list.py
deleted file mode 100644
index e8c61c4..0000000
--- a/algorithms/tests/test_list.py
+++ /dev/null
@@ -1,62 +0,0 @@
-import unittest
-
-import algorithms.list as list
-
-
-class List(unittest.TestCase):
-
-    def setUp(self):
-        pass
-
-    def test_find_max_sub(self):
-        bounds, m = [e for e in list.find_max_sub([-2, 3, -4, 5, 1, -5])]
-        self.assertEqual(bounds, (3, 4))
-        self.assertEqual(m, 6)
-
-    def test_find_int_first_half(self):
-        idx = list.find_int(4, [1, 2, 4, 5, 7, 9])
-        self.assertEqual(idx, 2)
-
-    def test_find_int_second_half(self):
-        idx = list.find_int(7, [1, 2, 4, 5, 7, 9])
-        self.assertEqual(idx, 4)
-
-    def test_find_int_not_found(self):
-        idx = list.find_int(3, [1, 2, 4, 5, 7, 9])
-        self.assertIsNone(idx)
-
-    def test_find_int_single_element_list(self):
-        idx = list.find_int(3, [3, ])
-        self.assertEqual(idx, 0)
-
-    def test_find_int_empty_list(self):
-        idx = list.find_int(3, [])
-        self.assertIsNone(idx)
-
-    def test_merge_sort(self):
-        res = list.merge_sort([3, 4, 1, 5, 0])
-        self.assertListEqual(res, [0, 1, 3, 4, 5])
-
-    def test_merge_sort_duplicates(self):
-        res = list.merge_sort([3, 4, 1, 5, 0, 4])
-        self.assertListEqual(res, [0, 1, 3, 4, 4, 5])
-
-    def test_merge_sort_single_element(self):
-        res = list.merge_sort([3])
-        self.assertListEqual(res, [3])
-
-    def test_quicksort(self):
-        res = list.quicksort([3, 4, 1, 5, 0])
-        self.assertListEqual(res, [0, 1, 3, 4, 5])
-
-    def test_quicksort_duplicates(self):
-        res = list.quicksort([3, 4, 1, 5, 4, 0, 1])
-        self.assertListEqual(res, [0, 1, 1, 3, 4, 4, 5])
-
-    def test_quicksort_single_element(self):
-        res = list.quicksort([3])
-        self.assertListEqual(res, [3])
-
-
-if __name__ == '__main__':
-    unittest.main()

From f0487717e1abbc8fd821d71a5d6f2e4b4527079a Mon Sep 17 00:00:00 2001
From: Laurent Luce <laurentluce49@yahoo.com>
Date: Sun, 27 Dec 2020 18:39:41 -0500
Subject: [PATCH 03/16] Pants for CI.

---
 BUILD                  | 17 +++++++++++++++++
 algorithms/BUILD       |  7 +++++++
 algorithms/tests/BUILD |  3 +++
 build-support/.flake8  |  1 +
 constraints.txt        |  0
 pants.toml             | 26 ++++++++++++++++++++++++++
 requirements.txt       |  0
 setup.py               | 29 -----------------------------
 8 files changed, 54 insertions(+), 29 deletions(-)
 create mode 100644 BUILD
 create mode 100644 algorithms/BUILD
 create mode 100644 algorithms/tests/BUILD
 create mode 100644 build-support/.flake8
 create mode 100644 constraints.txt
 create mode 100644 pants.toml
 create mode 100644 requirements.txt
 delete mode 100644 setup.py

diff --git a/BUILD b/BUILD
new file mode 100644
index 0000000..feacd05
--- /dev/null
+++ b/BUILD
@@ -0,0 +1,17 @@
+python_requirements()
+
+python_distribution(
+    name="python-algorithms",
+    dependencies=[
+    ],
+    provides=setup_py(
+        name="python-algorithms",
+        version="1.0",
+        description="Python algorithms.",
+        author="Laurent Luce",
+        classifiers=[
+            "Programming Language :: Python :: 3.6",
+        ],
+    ),
+    setup_py_commands=["sdist", "bdist_wheel", "--python-tag", "py36.py37"]
+)
diff --git a/algorithms/BUILD b/algorithms/BUILD
new file mode 100644
index 0000000..92cbbb1
--- /dev/null
+++ b/algorithms/BUILD
@@ -0,0 +1,7 @@
+python_library(
+    name="algorithms",
+    sources=["*.py", "!*_test.py"],
+    interpreter_constraints=[">=3.6"],
+)
+
+
diff --git a/algorithms/tests/BUILD b/algorithms/tests/BUILD
new file mode 100644
index 0000000..7fb50a5
--- /dev/null
+++ b/algorithms/tests/BUILD
@@ -0,0 +1,3 @@
+# `sources` defaults to ['*_test.py', 'test_*.py', 'conftest.py'].
+# `dependencies` are inferred.
+python_tests(name = 'tests')
diff --git a/build-support/.flake8 b/build-support/.flake8
new file mode 100644
index 0000000..ef09bcb
--- /dev/null
+++ b/build-support/.flake8
@@ -0,0 +1 @@
+[flake8]
diff --git a/constraints.txt b/constraints.txt
new file mode 100644
index 0000000..e69de29
diff --git a/pants.toml b/pants.toml
new file mode 100644
index 0000000..5a9c159
--- /dev/null
+++ b/pants.toml
@@ -0,0 +1,26 @@
+[GLOBAL]
+pants_version = "2.1.0"
+backend_packages = [
+  "pants.backend.python",
+  "pants.backend.python.lint.flake8"
+]
+
+[source]
+# The Python source root is the repo root. See https://www.pantsbuild.org/docs/source-roots.
+root_patterns = ["/"]
+
+[python-setup]
+# The default interpreter compatibility for code in this repo. Individual targets can override
+#  this with the `interpreter_constraints` field. See
+#  https://www.pantsbuild.org/docs/python-interpreter-compatibility.
+interpreter_constraints = [">=3.6"]
+# Use a constraints file. See https://www.pantsbuild.org/docs/python-third-party-dependencies.
+requirement_constraints = "constraints.txt"
+# We search for interpreters on both on the $PATH and in the `$(pyenv root)/versions` folder.
+#  If you're using macOS, you may want to leave off the <PATH> entry to avoid using the
+#  problematic system Pythons. See
+#  https://www.pantsbuild.org/docs/python-interpreter-compatibility#changing-the-interpreter-search-path.
+interpreter_search_paths = ["<PATH>", "<PYENV>"]
+
+[flake8]
+config = "build-support/.flake8"
diff --git a/requirements.txt b/requirements.txt
new file mode 100644
index 0000000..e69de29
diff --git a/setup.py b/setup.py
deleted file mode 100644
index 0137842..0000000
--- a/setup.py
+++ /dev/null
@@ -1,29 +0,0 @@
-from distutils.core import setup
-setup(
-    name = "algorithms",
-    packages = ['algorithms'],
-    version = "0.1",
-    description = "Algorithms implemented in Python",
-    author = "Laurent Luce",
-    author_email = "laurentluce49@yahoo.com",
-    url = "http://github.com/laurentluce/python-algorithms",
-    download_url = "http://github.com/laurentluce/python-algorithms",
-    keywords = ["algorithms"],
-    classifiers = [
-        "Programming Language :: Python",
-        "Operating System :: OS Independent",
-        "License :: OSI Approved :: MIT License",
-        "Intended Audience :: Developers",
-        "Development Status :: 5 - Production/Stable",
-        "Topic :: Software Development :: Libraries :: Python Modules"
-        ],
-    long_description = """\
-    Python Algorithms Library
-    ----------------------------
-    
-    DESCRIPTION
-    The purpose of this library is to help you with basic and more advanced
-    algorithms
-    
-    LICENSE The Python Algorithms Library is distributed under the MIT
-    License """ )

From 38e11a8450ef9781154487e1dd8aedd192286d6f Mon Sep 17 00:00:00 2001
From: Laurent Luce <laurentluce49@yahoo.com>
Date: Sun, 27 Dec 2020 18:40:32 -0500
Subject: [PATCH 04/16] Pants for CI.

---
 pants | 294 ++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
 1 file changed, 294 insertions(+)
 create mode 100755 pants

diff --git a/pants b/pants
new file mode 100755
index 0000000..e9b5768
--- /dev/null
+++ b/pants
@@ -0,0 +1,294 @@
+#!/usr/bin/env bash
+# Copyright 2020 Pants project contributors (see CONTRIBUTORS.md).
+# Licensed under the Apache License, Version 2.0 (see LICENSE).
+
+# =============================== NOTE ===============================
+# This ./pants bootstrap script comes from the pantsbuild/setup
+# project. It is intended to be checked into your code repository so
+# that other developers have the same setup.
+#
+# Learn more here: https://www.pantsbuild.org/docs/installation
+# ====================================================================
+
+set -eou pipefail
+
+# NOTE: To use an unreleased version of Pants from the pantsbuild/pants master branch,
+#  locate the master branch SHA, set PANTS_SHA=<SHA> in the environment, and run this script as usual.
+#
+# E.g., PANTS_SHA=725fdaf504237190f6787dda3d72c39010a4c574 ./pants --version
+
+PYTHON_BIN_NAME="${PYTHON:-unspecified}"
+
+# Set this to specify a non-standard location for this script to read the Pants version from.
+# NB: This will *not* cause Pants itself to use this location as a config file.
+#     You can use PANTS_CONFIG_FILES or --pants-config-files to do so.
+PANTS_TOML=${PANTS_TOML:-pants.toml}
+
+PANTS_BIN_NAME="${PANTS_BIN_NAME:-$0}"
+
+PANTS_SETUP_CACHE="${PANTS_SETUP_CACHE:-${XDG_CACHE_HOME:-$HOME/.cache}/pants/setup}"
+# If given a relative path, we fix it to be absolute.
+if [[ "$PANTS_SETUP_CACHE" != /* ]]; then
+  PANTS_SETUP_CACHE="${PWD}/${PANTS_SETUP_CACHE}"
+fi
+
+PANTS_BOOTSTRAP="${PANTS_SETUP_CACHE}/bootstrap-$(uname -s)-$(uname -m)"
+
+VENV_VERSION=${VENV_VERSION:-20.2.2}
+
+VENV_PACKAGE=virtualenv-${VENV_VERSION}
+VENV_TARBALL=${VENV_PACKAGE}.tar.gz
+
+COLOR_RED="\x1b[31m"
+COLOR_GREEN="\x1b[32m"
+COLOR_RESET="\x1b[0m"
+
+function log() {
+  echo -e "$@" 1>&2
+}
+
+function die() {
+  (($# > 0)) && log "${COLOR_RED}$*${COLOR_RESET}"
+  exit 1
+}
+
+function green() {
+  (($# > 0)) && log "${COLOR_GREEN}$*${COLOR_RESET}"
+}
+
+function tempdir {
+  mktemp -d "$1"/pants.XXXXXX
+}
+
+function get_exe_path_or_die {
+  local exe="$1"
+  if ! command -v "${exe}"; then
+    die "Could not find ${exe}. Please ensure ${exe} is on your PATH."
+  fi
+}
+
+function get_pants_config_value {
+  local config_key="$1"
+  local optional_space="[[:space:]]*"
+  local prefix="^${config_key}${optional_space}=${optional_space}"
+  local raw_value
+  raw_value="$(sed -ne "/${prefix}/ s#${prefix}##p" "${PANTS_TOML}")"
+  echo "${raw_value}"  | tr -d \"\' && return 0
+  return 0
+}
+
+function get_python_major_minor_version {
+  local python_exe="$1"
+  "$python_exe" <<EOF
+import sys
+major_minor_version = ''.join(str(version_num) for version_num in sys.version_info[0:2])
+print(major_minor_version)
+EOF
+}
+
+# The high-level flow:
+#
+# 1.) Resolve the Pants version from config so that we know what interpreters we can use, what to name the venv,
+#     and what to install via pip.
+# 2.) Resolve the Python interpreter, first reading from the env var $PYTHON, then using a default based on the Pants
+#     version.
+# 3.) Check if the venv already exists via a naming convention, and create the venv if not found.
+# 4.) Execute Pants with the resolved Python interpreter and venv.
+#
+# After that, Pants itself will handle making sure any requested plugins
+# are installed and up to date.
+
+function determine_pants_version {
+  if [ -n "${PANTS_SHA:-}" ]; then
+    # get_version_for_sha will echo the version, thus "returning" it from this function.
+    get_version_for_sha "$PANTS_SHA"
+    return
+  fi
+
+  pants_version="$(get_pants_config_value 'pants_version')"
+  if [[ -z "${pants_version}" ]]; then
+    die "Please explicitly specify the \`pants_version\` in your \`pants.toml\` under the
+\`[GLOBAL]\` scope. See https://pypi.org/project/pantsbuild.pants/#history for all released
+versions and https://www.pantsbuild.org/docs/installation for more instructions."
+  fi
+  pants_major_version="$(echo "${pants_version}" | cut -d '.' -f1)"
+  pants_minor_version="$(echo "${pants_version}" | cut -d '.' -f2)"
+  # 1.26 is the first version to support `pants.toml`, so we fail eagerly if using an outdated version.
+  if [[ "${pants_major_version}" -eq 1 && "${pants_minor_version}" -le 25 ]]; then
+    die "This version of the \`./pants\` script does not work with Pants <= 1.25.0 (and it also requires using \`pants.toml\`,
+rather than \`pants.ini\`). Instead, either upgrade your \`pants_version\` or use the version of the \`./pants\` script
+at https://raw.githubusercontent.com/Eric-Arellano/setup/0d445edef57cb89fd830db70810e38f050b0a268/pants."
+  fi
+  echo "${pants_version}"
+}
+
+function set_supported_python_versions {
+  local pants_version="$1"
+  local pants_major_version
+  local pants_minor_version
+  pants_major_version="$(echo "${pants_version}" | cut -d '.' -f1)"
+  pants_minor_version="$(echo "${pants_version}" | cut -d '.' -f2)"
+  if [[ "${pants_major_version}" -eq 1 ]]; then
+    supported_python_versions_decimal=('3.6' '3.7' '3.8')
+    supported_python_versions_int=('36' '37' '38')
+    supported_message='3.6, 3.7, or 3.8'
+  elif [[ "${pants_major_version}" -eq 2 && "${pants_minor_version}" -eq 0 ]]; then
+    supported_python_versions_decimal=('3.6' '3.7' '3.8')
+    supported_python_versions_int=('36' '37' '38')
+    supported_message='3.6, 3.7, or 3.8'
+  elif [[ "${pants_major_version}" -eq 2 && "${pants_minor_version}" -eq 1 ]]; then
+    supported_python_versions_decimal=('3.7' '3.8' '3.6')
+    supported_python_versions_int=('37' '38' '36')
+    supported_message='3.7, 3.8, or 3.6 (deprecated)'
+  else
+    supported_python_versions_decimal=('3.7' '3.8')
+    supported_python_versions_int=('37' '38')
+    supported_message='3.7 or 3.8'
+  fi
+}
+
+function determine_default_python_exe {
+  for version in "${supported_python_versions_decimal[@]}"; do
+    local interpreter_path
+    interpreter_path="$(command -v "python${version}")"
+    if [[ -z "${interpreter_path}" ]]; then
+      continue
+    fi
+    # Check if the Python version is installed via Pyenv but not activated.
+    if [[ "$("${interpreter_path}" --version 2>&1 > /dev/null)" == "pyenv: python${version}"* ]]; then
+      continue
+    fi
+    echo "${interpreter_path}" && return 0
+  done
+}
+
+function determine_python_exe {
+  local pants_version="$1"
+  set_supported_python_versions "${pants_version}"
+  local requirement_str="For \`pants_version = \"${pants_version}\"\`, Pants requires Python ${supported_message} to run."
+
+  local python_bin_name
+  if [[ "${PYTHON_BIN_NAME}" != 'unspecified' ]]; then
+    python_bin_name="${PYTHON_BIN_NAME}"
+  else
+    python_bin_name="$(determine_default_python_exe)"
+    if [[ -z "${python_bin_name}" ]]; then
+      die "No valid Python interpreter found. ${requirement_str} Please check that a valid interpreter is installed and on your \$PATH."
+    fi
+  fi
+  local python_exe
+  python_exe="$(get_exe_path_or_die "${python_bin_name}")"
+  local major_minor_version
+  major_minor_version="$(get_python_major_minor_version "${python_exe}")"
+  for valid_version in "${supported_python_versions_int[@]}"; do
+    if [[ "${major_minor_version}" == "${valid_version}" ]]; then
+      echo "${python_exe}" && return 0
+    fi
+  done
+  die "Invalid Python interpreter version for ${python_exe}. ${requirement_str}"
+}
+
+# TODO(John Sirois): GC race loser tmp dirs leftover from bootstrap_XXX
+# functions.  Any tmp dir w/o a symlink pointing to it can go.
+
+function bootstrap_venv {
+  if [[ ! -d "${PANTS_BOOTSTRAP}/${VENV_PACKAGE}" ]]; then
+    (
+      mkdir -p "${PANTS_BOOTSTRAP}"
+      local staging_dir
+      staging_dir=$(tempdir "${PANTS_BOOTSTRAP}")
+      cd "${staging_dir}"
+      curl -LO "https://pypi.io/packages/source/v/virtualenv/${VENV_TARBALL}"
+      tar -xzf "${VENV_TARBALL}"
+      ln -s "${staging_dir}/${VENV_PACKAGE}" "${staging_dir}/latest"
+      mv "${staging_dir}/latest" "${PANTS_BOOTSTRAP}/${VENV_PACKAGE}"
+    ) 1>&2
+  fi
+
+  local venv_path="${PANTS_BOOTSTRAP}/${VENV_PACKAGE}"
+  local venv_entry_point
+
+  # shellcheck disable=SC2086
+  if [[ -f "${venv_path}/virtualenv.py" ]]; then
+    venv_entry_point="${venv_path}/virtualenv.py"
+  elif [[ -f "${venv_path}/src/virtualenv/__main__.py" ]]; then
+    venv_entry_point="${venv_path}/src/virtualenv/__main__.py"
+  else
+    die "Could not find virtualenv entry point for version $VENV_VERSION"
+  fi
+
+  echo "${venv_entry_point}"
+}
+
+function find_links_url {
+  local pants_version="$1"
+  local pants_sha="$2"
+  echo -n "https://binaries.pantsbuild.org/wheels/pantsbuild.pants/${pants_sha}/${pants_version/+/%2B}/index.html"
+}
+
+function get_version_for_sha {
+  local sha="$1"
+
+  # Retrieve the Pants version associated with this commit.
+  local pants_version
+  pants_version="$(curl --fail -sL "https://raw.githubusercontent.com/pantsbuild/pants/${sha}/src/python/pants/VERSION")"
+
+  # Construct the version as the release version from src/python/pants/VERSION, plus the string `+gitXXXXXXXX`,
+  # where the XXXXXXXX is the first 8 characters of the SHA.
+  echo "${pants_version}+git${sha:0:8}"
+}
+
+function bootstrap_pants {
+  local pants_version="$1"
+  local python="$2"
+  local pants_sha="${3:-}"
+
+  local pants_requirement="pantsbuild.pants==${pants_version}"
+  local maybe_find_links
+  if [[ -z "${pants_sha}" ]]; then
+    maybe_find_links=""
+  else
+    maybe_find_links="--find-links=$(find_links_url "${pants_version}" "${pants_sha}")"
+   fi
+  local python_major_minor_version
+  python_major_minor_version="$(get_python_major_minor_version "${python}")"
+  local target_folder_name
+  target_folder_name="${pants_version}_py${python_major_minor_version}"
+
+  if [[ ! -d "${PANTS_BOOTSTRAP}/${target_folder_name}" ]]; then
+    (
+      local venv_entry_point="$(bootstrap_venv)"
+      local staging_dir
+      staging_dir=$(tempdir "${PANTS_BOOTSTRAP}")
+      "${python}" "${venv_entry_point}" --no-download "${staging_dir}/install" && \
+      "${staging_dir}/install/bin/pip" install -U pip && \
+      "${staging_dir}/install/bin/pip" install ${maybe_find_links} --progress-bar off "${pants_requirement}" && \
+      ln -s "${staging_dir}/install" "${staging_dir}/${target_folder_name}" && \
+      mv "${staging_dir}/${target_folder_name}" "${PANTS_BOOTSTRAP}/${target_folder_name}" && \
+      green "New virtual environment successfully created at ${PANTS_BOOTSTRAP}/${target_folder_name}."
+    ) 1>&2
+  fi
+  echo "${PANTS_BOOTSTRAP}/${target_folder_name}"
+}
+
+# Ensure we operate from the context of the ./pants buildroot.
+cd "$(cd "$(dirname "${BASH_SOURCE[0]}")" && pwd -P)"
+pants_version="$(determine_pants_version)"
+python="$(determine_python_exe "${pants_version}")"
+pants_dir="$(bootstrap_pants "${pants_version}" "${python}" "${PANTS_SHA:-}")"
+pants_python="${pants_dir}/bin/python"
+pants_binary="${pants_dir}/bin/pants"
+pants_extra_args=""
+if [[ -n "${PANTS_SHA:-}" ]]; then
+  pants_extra_args="${pants_extra_args} --python-repos-repos=$(find_links_url "$pants_version" "$PANTS_SHA")"
+fi
+
+# We set the env var no_proxy to '*', to work around an issue with urllib using non
+# async-signal-safe syscalls after we fork a process that has already spawned threads.
+#
+# See https://blog.phusion.nl/2017/10/13/why-ruby-app-servers-break-on-macos-high-sierra-and-what-can-be-done-about-it/
+export no_proxy='*'
+
+# shellcheck disable=SC2086
+exec "${pants_python}" "${pants_binary}" ${pants_extra_args} \
+  --pants-bin-name="${PANTS_BIN_NAME}" --pants-version=${pants_version} "$@"

From d2f6cb4deecadf14c200dfe0d38719f509e282e0 Mon Sep 17 00:00:00 2001
From: Laurent Luce <laurentluce49@yahoo.com>
Date: Sun, 27 Dec 2020 18:40:54 -0500
Subject: [PATCH 05/16] Pants for CI.

---
 algorithms/tests/all_tests.py | 20 --------------------
 1 file changed, 20 deletions(-)
 delete mode 100644 algorithms/tests/all_tests.py

diff --git a/algorithms/tests/all_tests.py b/algorithms/tests/all_tests.py
deleted file mode 100644
index ba9bc3b..0000000
--- a/algorithms/tests/all_tests.py
+++ /dev/null
@@ -1,20 +0,0 @@
-"""Run all of the tests."""
-import sys
-import unittest2 as unittest
-
-
-def main(args=None):
-    unittest_dir = '.'
-    unittest_suite = unittest.defaultTestLoader.discover(unittest_dir)
-
-    kwargs = {}
-    if args and '-v' in args:
-        kwargs['verbosity'] = 2
-    runner = unittest.TextTestRunner(sys.stdout, "Unittests",
-                                     **kwargs)
-    results = runner.run(unittest_suite)
-    return results.wasSuccessful()
-
-if __name__ == '__main__':
-    status = main(sys.argv[1:])
-    sys.exit(int(not status))

From 62e988ecbe3223f06279d69bc0c54265b56e0f97 Mon Sep 17 00:00:00 2001
From: Laurent Luce <laurentluce49@yahoo.com>
Date: Sun, 27 Dec 2020 18:41:15 -0500
Subject: [PATCH 06/16] Linting and Py3 support.

---
 algorithms/a_star_path_finding.py            |  3 +++
 algorithms/permutations.py                   | 14 +++++++-------
 algorithms/string.py                         |  4 ++--
 algorithms/tests/coverage.sh                 |  2 --
 algorithms/tests/test_a_star_path_finding.py |  2 +-
 5 files changed, 13 insertions(+), 12 deletions(-)
 delete mode 100644 algorithms/tests/coverage.sh

diff --git a/algorithms/a_star_path_finding.py b/algorithms/a_star_path_finding.py
index e239247..1448cb7 100644
--- a/algorithms/a_star_path_finding.py
+++ b/algorithms/a_star_path_finding.py
@@ -21,6 +21,9 @@ def __init__(self, x, y, reachable):
         self.h = 0
         self.f = 0
 
+    def __lt__(self, other):
+        return self.f < other.f
+
 
 class AStar(object):
     def __init__(self):
diff --git a/algorithms/permutations.py b/algorithms/permutations.py
index 0c789b1..f013d2d 100644
--- a/algorithms/permutations.py
+++ b/algorithms/permutations.py
@@ -1,11 +1,11 @@
-def permutations(l):
+def permutations(lst):
     """Generator for list permutations.
 
-    @param l list to generate permutations for
+    @param lst list to generate permutations for
     @result yield each permutation
 
     Example:
-    l = [1,2,3]
+    lst = [1,2,3]
     a = [1]
     permutations([2,3]) = [[2,3], [3,2]]
     [2,3]
@@ -17,10 +17,10 @@ def permutations(l):
     yield [3,1,2]
     yield [3,2,1]
     """
-    if len(l) <= 1:
-        yield l
+    if len(lst) <= 1:
+        yield lst
     else:
-        a = [l.pop(0)]
-        for p in permutations(l):
+        a = [lst.pop(0)]
+        for p in permutations(lst):
             for i in range(len(p)+1):
                 yield p[:i] + a + p[i:]
diff --git a/algorithms/string.py b/algorithms/string.py
index 8f6d134..e653263 100644
--- a/algorithms/string.py
+++ b/algorithms/string.py
@@ -187,11 +187,11 @@ def reverse_string_words(s):
     @param s string words to reverse.
     @returns reversed string words.
     """
-    def reverse(l, i, j):
+    def reverse(lst, i, j):
         # 'word1' -> '1drow'
         # Complexity: O(n/2)
         while i != j:
-            l[i], l[j] = l[j], l[i]
+            lst[i], lst[j] = lst[j], lst[i]
             i += 1
             j -= 1
 
diff --git a/algorithms/tests/coverage.sh b/algorithms/tests/coverage.sh
deleted file mode 100644
index a69b3be..0000000
--- a/algorithms/tests/coverage.sh
+++ /dev/null
@@ -1,2 +0,0 @@
-coverage run --source=$PYTHONPATH/algorithms --omit=$PYTHONPATH/algorithms/tests/* all_tests.py
-coverage report --omit=$PYTHONPATH/algorithms/tests/* -m
diff --git a/algorithms/tests/test_a_star_path_finding.py b/algorithms/tests/test_a_star_path_finding.py
index e95b7eb..c2e991e 100644
--- a/algorithms/tests/test_a_star_path_finding.py
+++ b/algorithms/tests/test_a_star_path_finding.py
@@ -14,7 +14,7 @@ def test_maze(self):
                  (3, 1), (3, 2), (3, 5), (4, 1), (4, 4), (5, 1))
         a.init_grid(6, 6, walls, (0, 0), (5, 5))
         path = a.solve()
-        self.assertEqual(path, [(0, 0), (0, 1), (0, 2), (0, 3), (0, 4), (1, 4),
+        self.assertEqual(path, [(0, 0), (0, 1), (0, 2), (1, 2), (1, 3), (1, 4),
                                 (2, 4), (3, 4), (3, 3), (4, 3), (5, 3), (5, 4),
                                 (5, 5)])
 

From e7719c43aa5069d744b62bf902f856a6fbac0893 Mon Sep 17 00:00:00 2001
From: Laurent Luce <laurentluce49@yahoo.com>
Date: Sun, 27 Dec 2020 18:42:35 -0500
Subject: [PATCH 07/16] .gitignore

---
 .gitignore | 59 ++++++++++++++++++++++++++++++++++++++++++++++++++++++
 1 file changed, 59 insertions(+)
 create mode 100644 .gitignore

diff --git a/.gitignore b/.gitignore
new file mode 100644
index 0000000..86997e9
--- /dev/null
+++ b/.gitignore
@@ -0,0 +1,59 @@
+# Byte-compiled / optimized / DLL files
+__pycache__/
+*.py[cod]
+
+# C extensions
+*.so
+
+# Distribution / packaging
+.Python
+env/
+bin/
+build/
+develop-eggs/
+dist/
+eggs/
+lib/
+lib64/
+parts/
+sdist/
+var/
+*.egg-info/
+.installed.cfg
+*.egg
+
+# Installer logs
+pip-log.txt
+pip-delete-this-directory.txt
+
+# Unit test / coverage reports
+htmlcov/
+.tox/
+.coverage
+.cache
+nosetests.xml
+coverage.xml
+
+# Translations
+*.mo
+
+# Mr Developer
+.mr.developer.cfg
+.project
+.pydevproject
+
+# Rope
+.ropeproject
+
+# Django stuff:
+*.log
+*.pot
+
+# Sphinx documentation
+docs/_build/
+
+# Pants workspace files
+/.pants.d/
+/dist/
+/.pids
+/.pants.workdir.file_lock*

From 4ddcba45d2a9e1d43ab3fdcf29e53040f165302a Mon Sep 17 00:00:00 2001
From: Laurent Luce <laurentluce49@yahoo.com>
Date: Sun, 27 Dec 2020 19:13:08 -0500
Subject: [PATCH 08/16] Py2 and Py3 support.

---
 algorithms/a_star_path_finding.py | 2 ++
 algorithms/permutations.py        | 1 +
 algorithms/string.py              | 1 +
 3 files changed, 4 insertions(+)

diff --git a/algorithms/a_star_path_finding.py b/algorithms/a_star_path_finding.py
index 1448cb7..25c21d7 100644
--- a/algorithms/a_star_path_finding.py
+++ b/algorithms/a_star_path_finding.py
@@ -1,3 +1,5 @@
+from builtins import range
+from builtins import object
 import heapq
 
 
diff --git a/algorithms/permutations.py b/algorithms/permutations.py
index f013d2d..dd88fb2 100644
--- a/algorithms/permutations.py
+++ b/algorithms/permutations.py
@@ -1,3 +1,4 @@
+from builtins import range
 def permutations(lst):
     """Generator for list permutations.
 
diff --git a/algorithms/string.py b/algorithms/string.py
index e653263..b0e4a0a 100644
--- a/algorithms/string.py
+++ b/algorithms/string.py
@@ -1,3 +1,4 @@
+from builtins import range
 def string_matching_naive(text='', pattern=''):
     """Returns positions where pattern is found in text.
 

From a86ba64175869e4b31d327ad15fbcd7ad4d993fe Mon Sep 17 00:00:00 2001
From: Laurent Luce <laurentluce49@yahoo.com>
Date: Sun, 27 Dec 2020 19:13:20 -0500
Subject: [PATCH 09/16] Add .bak files to gitignore.

---
 .gitignore | 3 +++
 1 file changed, 3 insertions(+)

diff --git a/.gitignore b/.gitignore
index 86997e9..991b2c2 100644
--- a/.gitignore
+++ b/.gitignore
@@ -57,3 +57,6 @@ docs/_build/
 /dist/
 /.pids
 /.pants.workdir.file_lock*
+
+# Others
+*.bak

From b6bcf7befd282b7d66b79fbe43086de43831bdba Mon Sep 17 00:00:00 2001
From: Laurent Luce <laurentluce49@yahoo.com>
Date: Sun, 27 Dec 2020 20:02:36 -0500
Subject: [PATCH 10/16] Add two interpreters constraints: 2.7 and >=3.6.

---
 algorithms/BUILD                  | 2 +-
 algorithms/a_star_path_finding.py | 2 --
 algorithms/permutations.py        | 1 -
 algorithms/string.py              | 1 -
 algorithms/tests/BUILD            | 5 ++++-
 pants.toml                        | 6 +++++-
 6 files changed, 10 insertions(+), 7 deletions(-)

diff --git a/algorithms/BUILD b/algorithms/BUILD
index 92cbbb1..d06a175 100644
--- a/algorithms/BUILD
+++ b/algorithms/BUILD
@@ -1,7 +1,7 @@
 python_library(
     name="algorithms",
     sources=["*.py", "!*_test.py"],
-    interpreter_constraints=[">=3.6"],
+    interpreter_constraints=["==2.7.*", ">=3.6"],
 )
 
 
diff --git a/algorithms/a_star_path_finding.py b/algorithms/a_star_path_finding.py
index 25c21d7..1448cb7 100644
--- a/algorithms/a_star_path_finding.py
+++ b/algorithms/a_star_path_finding.py
@@ -1,5 +1,3 @@
-from builtins import range
-from builtins import object
 import heapq
 
 
diff --git a/algorithms/permutations.py b/algorithms/permutations.py
index dd88fb2..f013d2d 100644
--- a/algorithms/permutations.py
+++ b/algorithms/permutations.py
@@ -1,4 +1,3 @@
-from builtins import range
 def permutations(lst):
     """Generator for list permutations.
 
diff --git a/algorithms/string.py b/algorithms/string.py
index b0e4a0a..e653263 100644
--- a/algorithms/string.py
+++ b/algorithms/string.py
@@ -1,4 +1,3 @@
-from builtins import range
 def string_matching_naive(text='', pattern=''):
     """Returns positions where pattern is found in text.
 
diff --git a/algorithms/tests/BUILD b/algorithms/tests/BUILD
index 7fb50a5..e9edb5d 100644
--- a/algorithms/tests/BUILD
+++ b/algorithms/tests/BUILD
@@ -1,3 +1,6 @@
 # `sources` defaults to ['*_test.py', 'test_*.py', 'conftest.py'].
 # `dependencies` are inferred.
-python_tests(name = 'tests')
+python_tests(
+    name = 'tests',
+    interpreter_constraints=["==2.7.*", ">=3.6"],
+)
diff --git a/pants.toml b/pants.toml
index 5a9c159..0c3de5a 100644
--- a/pants.toml
+++ b/pants.toml
@@ -13,7 +13,7 @@ root_patterns = ["/"]
 # The default interpreter compatibility for code in this repo. Individual targets can override
 #  this with the `interpreter_constraints` field. See
 #  https://www.pantsbuild.org/docs/python-interpreter-compatibility.
-interpreter_constraints = [">=3.6"]
+interpreter_constraints = ["==2.7.*", ">=3.6"]
 # Use a constraints file. See https://www.pantsbuild.org/docs/python-third-party-dependencies.
 requirement_constraints = "constraints.txt"
 # We search for interpreters on both on the $PATH and in the `$(pyenv root)/versions` folder.
@@ -24,3 +24,7 @@ interpreter_search_paths = ["<PATH>", "<PYENV>"]
 
 [flake8]
 config = "build-support/.flake8"
+
+[pytest]
+version = "pytest>=4.0,<6.1"
+pytest_plugins = ["zipp>=1.2"]

From da6018e62488a50775c3b939ca031b8e124f7288 Mon Sep 17 00:00:00 2001
From: Laurent Luce <laurentluce49@yahoo.com>
Date: Sun, 27 Dec 2020 20:26:10 -0500
Subject: [PATCH 11/16] Tests using pants.

---
 README.md | 5 ++---
 1 file changed, 2 insertions(+), 3 deletions(-)

diff --git a/README.md b/README.md
index 99df38e..77f1a8b 100644
--- a/README.md
+++ b/README.md
@@ -19,10 +19,9 @@ String
 Generators
   - Permutations.
 
-### Installation
-Get the source and run
+### Tests
 
-    $ python setup.py install
+    $ ./pants test ::
 
 ### License
 The Python Algorithms Library is distributed under the MIT License

From 3edbb256e6156071c671e0e632e9d3b102659214 Mon Sep 17 00:00:00 2001
From: Laurent Luce <laurentluce49@yahoo.com>
Date: Fri, 29 Jan 2021 19:16:35 -0500
Subject: [PATCH 12/16] Add comments to string matching algos.

---
 algorithms/string.py | 11 ++++++++++-
 1 file changed, 10 insertions(+), 1 deletion(-)

diff --git a/algorithms/string.py b/algorithms/string.py
index e653263..a809fab 100644
--- a/algorithms/string.py
+++ b/algorithms/string.py
@@ -1,7 +1,7 @@
 def string_matching_naive(text='', pattern=''):
     """Returns positions where pattern is found in text.
 
-    We slide the string to match 'pattern' over the text
+    Sliding window.
 
     O((n-m)m)
     Example: text = 'ababbababa', pattern = 'aba'
@@ -24,6 +24,11 @@ def string_matching_naive(text='', pattern=''):
 def string_matching_rabin_karp(text='', pattern='', hash_base=256):
     """Returns positions where pattern is found in text.
 
+    Similar to the naive approach but matches the hash value of the pattern
+    with the hash value of current substring of text.  Needs to match
+    individual characters once a match is found because of potential
+    hash collisions.
+
     worst case: O(nm)
     O(n+m) if the number of valid matches is small and the pattern is large.
 
@@ -75,6 +80,8 @@ def hash_value(s, base):
 def string_matching_knuth_morris_pratt(text='', pattern=''):
     """Returns positions where pattern is found in text.
 
+    https://en.wikipedia.org/wiki/Knuth%E2%80%93Morris%E2%80%93Pratt_algorithm
+
     O(m+n)
     Example: text = 'ababbababa', pattern = 'aba'
         string_matching_knuth_morris_pratt(text, pattern) returns [0, 5, 7]
@@ -115,6 +122,8 @@ def compute_prefix_function(p):
 def string_matching_boyer_moore_horspool(text='', pattern=''):
     """Returns positions where pattern is found in text.
 
+    https://en.wikipedia.org/wiki/Boyer%E2%80%93Moore_string-search_algorithm
+
     O(n)
     Performance: ord() is slow so we shouldn't use it here
 

From abf8c3abe244893f11d9a46945f455a40839b86f Mon Sep 17 00:00:00 2001
From: Laurent Luce <laurentluce49@yahoo.com>
Date: Fri, 29 Jan 2021 19:28:25 -0500
Subject: [PATCH 13/16] Revert delete mistake.

---
 algorithms/binary_tree.py            | 166 +++++++++++++++++++++++++++
 algorithms/list.py                   | 122 ++++++++++++++++++++
 algorithms/tests/test_binary_tree.py | 165 ++++++++++++++++++++++++++
 algorithms/tests/test_list.py        |  62 ++++++++++
 4 files changed, 515 insertions(+)
 create mode 100644 algorithms/binary_tree.py
 create mode 100644 algorithms/list.py
 create mode 100644 algorithms/tests/test_binary_tree.py
 create mode 100644 algorithms/tests/test_list.py

diff --git a/algorithms/binary_tree.py b/algorithms/binary_tree.py
new file mode 100644
index 0000000..3e8c20b
--- /dev/null
+++ b/algorithms/binary_tree.py
@@ -0,0 +1,166 @@
+from __future__ import print_function
+
+
+class Node(object):
+    """Tree node: left and right child + data which can be any object
+
+    """
+    def __init__(self, data):
+        """Node constructor
+
+        @param data node data object
+        """
+        self.left = None
+        self.right = None
+        self.data = data
+
+    def insert(self, data):
+        """Insert new node with data
+
+        @param data node data object to insert
+        """
+        if self.data:
+            if data < self.data:
+                if self.left is None:
+                    self.left = Node(data)
+                else:
+                    self.left.insert(data)
+            elif data > self.data:
+                if self.right is None:
+                    self.right = Node(data)
+                else:
+                    self.right.insert(data)
+        else:
+            self.data = data
+
+    def lookup(self, data, parent=None):
+        """Lookup node containing data
+
+        @param data node data object to look up
+        @param parent node's parent
+        @returns node and node's parent if found or None, None
+        """
+        if data < self.data:
+            if self.left is None:
+                return None, None
+            return self.left.lookup(data, self)
+        elif data > self.data:
+            if self.right is None:
+                return None, None
+            return self.right.lookup(data, self)
+        else:
+            return self, parent
+
+    def delete(self, data):
+        """Delete node containing data
+
+        @param data node's content to delete
+        """
+        # get node containing data
+        node, parent = self.lookup(data)
+        if node is not None:
+            children_count = node.children_count()
+            if children_count == 0:
+                # if node has no children, just remove it
+                if parent:
+                    if parent.left is node:
+                        parent.left = None
+                    else:
+                        parent.right = None
+                else:
+                    self.data = None
+            elif children_count == 1:
+                # if node has 1 child
+                # replace node by its child
+                if node.left:
+                    n = node.left
+                else:
+                    n = node.right
+                if parent:
+                    if parent.left is node:
+                        parent.left = n
+                    else:
+                        parent.right = n
+                else:
+                    self.left = n.left
+                    self.right = n.right
+                    self.data = n.data
+            else:
+                # if node has 2 children
+                # find its successor
+                parent = node
+                successor = node.right
+                while successor.left:
+                    parent = successor
+                    successor = successor.left
+                # replace node data by its successor data
+                node.data = successor.data
+                # fix successor's parent node child
+                if parent.left == successor:
+                    parent.left = successor.right
+                else:
+                    parent.right = successor.right
+
+    def compare_trees(self, node):
+        """Compare 2 trees
+
+        @param node tree to compare
+        @returns True if the tree passed is identical to this tree
+        """
+        if node is None:
+            return False
+        if self.data != node.data:
+            return False
+        res = True
+        if self.left is None:
+            if node.left:
+                return False
+        else:
+            res = self.left.compare_trees(node.left)
+        if res is False:
+            return False
+        if self.right is None:
+            if node.right:
+                return False
+        else:
+            res = self.right.compare_trees(node.right)
+        return res
+
+    def print_tree(self):
+        """Print tree content inorder
+
+        """
+        if self.left:
+            self.left.print_tree()
+        print(self.data, end=" ")
+        if self.right:
+            self.right.print_tree()
+
+    def tree_data(self):
+        """Generator to get the tree nodes data
+
+        """
+        # we use a stack to traverse the tree in a non-recursive way
+        stack = []
+        node = self
+        while stack or node:
+            if node:
+                stack.append(node)
+                node = node.left
+            else:
+                # we are returning so we pop the node and we yield it
+                node = stack.pop()
+                yield node.data
+                node = node.right
+
+    def children_count(self):
+        """Return the number of children
+
+        @returns number of children: 0, 1, 2
+        """
+        cnt = 0
+        if self.left:
+            cnt += 1
+        if self.right:
+            cnt += 1
+        return cnt
diff --git a/algorithms/list.py b/algorithms/list.py
new file mode 100644
index 0000000..86fb40f
--- /dev/null
+++ b/algorithms/list.py
@@ -0,0 +1,122 @@
+def find_int(i, l):
+    """Find integer in a sorted list.
+
+    Example: 4 in [1, 3, 4, 6, 7, 9] -> 2
+    @param i integer to find.
+    @param l sorted list.
+    @returns index if found, None if not.
+    """
+    if l:
+        p_idx = len(l) / 2
+        p = l[p_idx]
+        if i == p:
+            return p_idx
+        elif len(l) == 1:
+            return
+        elif i < p:
+            res = find_int(i, l[:p_idx])
+            if res:
+                return res
+        elif i > p:
+            res = find_int(i, l[p_idx:])
+            if res:
+                return res + p_idx
+
+
+def find_max_sub(l):
+    """Find subset with higest sum.
+
+    Example: [-2, 3, -4, 5, 1, -5] -> (3,4), 6
+    @param l list
+    @returns subset bounds and highest sum
+    """
+    # max sum
+    max = l[0]
+    # current sum
+    m = 0
+    # max sum subset bounds
+    bounds = (0, 0)
+    # current subset start
+    s = 0
+    for i in range(len(l)):
+        m += l[i]
+        if m > max:
+            max = m
+            bounds = (s, i)
+        elif m < 0:
+            m = 0
+            s = i+1
+    return bounds, max
+
+
+def merge_sort(l):
+    """Sort list using merge sort.
+
+    Complexity: O(n log n)
+
+    @param l list to sort.
+    @returns sorted list.
+    """
+    def merge(l1, l2):
+        """Merge sorted lists l1 and l2.
+
+        [1, 2, 4], [1, 3, 4, 5] -> [1, 1, 2, 3, 4, 5]
+        @param l1 sorted list
+        @param l2 sorted list
+        @returns merge sorted list
+        """
+        res = []
+        i = 0
+        j = 0
+        while i < len(l1) and j < len(l2):
+            if l1[i] <= l2[j]:
+                res.append(l1[i])
+                i += 1
+            elif l2[j] < l1[i]:
+                res.append(l2[j])
+                j += 1
+
+        while i < len(l1):
+            res.append(l1[i])
+            i += 1
+
+        while j < len(l2):
+            res.append(l2[j])
+            j += 1
+
+        return res
+
+    length = len(l)
+    if length <= 1:
+        return l
+    mid = length / 2
+    h1 = merge_sort(l[:mid])
+    h2 = merge_sort(l[mid:])
+
+    return merge(h1, h2)
+
+
+def quicksort(l):
+    """Sort list using quick sort.
+
+    Complexity: O(n log n).  Worst: O(n2)
+
+    @param l list to sort.
+    @returns sorted list.
+    """
+    if len(l) <= 1:
+        return l
+
+    pivot = l[0]
+    less = []
+    equal = []
+    greater = []
+    for e in l:
+        if e < pivot:
+            less.append(e)
+        elif e == pivot:
+            equal.append(e)
+        else:
+            greater.append(e)
+
+    return quicksort(less) + equal + quicksort(greater)
diff --git a/algorithms/tests/test_binary_tree.py b/algorithms/tests/test_binary_tree.py
new file mode 100644
index 0000000..0ec3397
--- /dev/null
+++ b/algorithms/tests/test_binary_tree.py
@@ -0,0 +1,165 @@
+import copy
+import unittest
+
+import algorithms.binary_tree as binary_tree
+
+
+class BinaryTreeTest(unittest.TestCase):
+
+    def setUp(self):
+        self.root_single_node = binary_tree.Node(None)
+        self.root = binary_tree.Node(10)
+        self.root.left = binary_tree.Node(5)
+        self.root.left.left = binary_tree.Node(3)
+        self.root.left.right = binary_tree.Node(7)
+        self.root.right = binary_tree.Node(15)
+        self.root.right.left = binary_tree.Node(12)
+        self.root.right.left.left = binary_tree.Node(11)
+        self.root.right.right = binary_tree.Node(20)
+        self.root_copy = copy.deepcopy(self.root)
+
+    def test_insert(self):
+        root = self.root_single_node
+
+        root.insert(10)
+        self.assertEqual(root.data, 10)
+
+        root.insert(5)
+        self.assertEqual(root.left.data, 5)
+
+        root.insert(15)
+        self.assertEqual(root.right.data, 15)
+
+        root.insert(8)
+        self.assertEqual(root.left.right.data, 8)
+
+        root.insert(2)
+        self.assertEqual(root.left.left.data, 2)
+
+        root.insert(12)
+        self.assertEqual(root.right.left.data, 12)
+
+        root.insert(17)
+        self.assertEqual(root.right.right.data, 17)
+
+    def test_lookup(self):
+        node, parent = self.root.lookup(0)
+        self.assertIsNone(parent)
+        self.assertIsNone(node)
+
+        node, parent = self.root.lookup(13)
+        self.assertIsNone(parent)
+        self.assertIsNone(node)
+
+        node, parent = self.root.lookup(7)
+        self.assertIs(node, self.root.left.right)
+        self.assertIs(parent, self.root.left)
+
+    def test_delete_root_no_child(self):
+        self.root_single_node.data = 7
+        self.root_single_node.delete(7)
+        self.assertIsNone(self.root_single_node.data)
+
+    def test_delete_root_one_child(self):
+        self.root_single_node.data = 7
+        self.root_single_node.insert(3)
+        self.root_single_node.delete(7)
+        self.assertEqual(self.root_single_node.data, 3)
+
+    def test_delete_one_child_left(self):
+        self.root.delete(12)
+        self.assertEqual(self.root.left.data, 5)
+        self.assertEqual(self.root.left.left.data, 3)
+        self.assertEqual(self.root.left.right.data, 7)
+        self.assertEqual(self.root.right.data, 15)
+        self.assertEqual(self.root.right.left.data, 11)
+        self.assertEqual(self.root.right.right.data, 20)
+
+    def test_delete_one_child_right(self):
+        self.root.insert(25)
+        self.root.delete(20)
+        self.assertEqual(self.root.left.data, 5)
+        self.assertEqual(self.root.left.left.data, 3)
+        self.assertEqual(self.root.left.right.data, 7)
+        self.assertEqual(self.root.right.data, 15)
+        self.assertEqual(self.root.right.left.data, 12)
+        self.assertEqual(self.root.right.left.left.data, 11)
+        self.assertEqual(self.root.right.right.data, 25)
+
+    def test_delete_right_leaf(self):
+        self.root.delete(7)
+        self.assertIsNone(self.root.left.right)
+        self.assertEqual(self.root.left.data, 5)
+        self.assertEqual(self.root.left.left.data, 3)
+        self.assertEqual(self.root.right.data, 15)
+        self.assertEqual(self.root.right.left.data, 12)
+        self.assertEqual(self.root.right.left.left.data, 11)
+        self.assertEqual(self.root.right.right.data, 20)
+
+    def test_delete_left_leaf(self):
+        self.root.delete(3)
+        self.assertIsNone(self.root.left.left)
+        self.assertEqual(self.root.left.data, 5)
+        self.assertEqual(self.root.left.right.data, 7)
+        self.assertEqual(self.root.right.data, 15)
+        self.assertEqual(self.root.right.left.data, 12)
+        self.assertEqual(self.root.right.left.left.data, 11)
+        self.assertEqual(self.root.right.right.data, 20)
+
+    def test_delete_right_node_two_childs(self):
+        self.root.delete(15)
+        self.assertEqual(self.root.left.data, 5)
+        self.assertEqual(self.root.left.left.data, 3)
+        self.assertEqual(self.root.left.right.data, 7)
+        self.assertEqual(self.root.right.data, 20)
+        self.assertEqual(self.root.right.left.data, 12)
+        self.assertEqual(self.root.right.left.left.data, 11)
+
+    def test_delete_left_node_two_childs(self):
+        self.root.delete(5)
+        self.assertEqual(self.root.left.data, 7)
+        self.assertEqual(self.root.left.left.data, 3)
+        self.assertEqual(self.root.right.data, 15)
+        self.assertEqual(self.root.right.left.data, 12)
+        self.assertEqual(self.root.right.left.left.data, 11)
+        self.assertEqual(self.root.right.right.data, 20)
+
+    def test_delete_root_two_childs(self):
+        self.root.delete(10)
+        self.assertEqual(self.root.left.data, 5)
+        self.assertEqual(self.root.left.left.data, 3)
+        self.assertEqual(self.root.left.right.data, 7)
+        self.assertEqual(self.root.data, 11)
+        self.assertEqual(self.root.right.data, 15)
+        self.assertEqual(self.root.right.left.data, 12)
+        self.assertEqual(self.root.right.right.data, 20)
+
+    def test_compare_trees_left_leaf_missing(self):
+        self.root_copy.delete(11)
+        self.assertFalse(self.root.compare_trees(self.root_copy))
+
+    def test_compare_trees_right_leaf_missing(self):
+        self.root_copy.delete(20)
+        self.assertFalse(self.root.compare_trees(self.root_copy))
+
+    def test_compare_trees_diff_value(self):
+        self.root_copy.left.data = 16
+        self.assertFalse(self.root.compare_trees(self.root_copy))
+
+    def test_compare_trees_extra_right_leaf(self):
+        self.root_copy.insert(25)
+        self.assertFalse(self.root.compare_trees(self.root_copy))
+
+    def test_compare_trees_extra_left_leaf(self):
+        self.root_copy.insert(18)
+        self.assertFalse(self.root.compare_trees(self.root_copy))
+
+    def test_print_tree(self):
+        self.root.print_tree()
+
+    def test_tree_data(self):
+        self.assertEqual([e for e in self.root.tree_data()],
+                         [3, 5, 7, 10, 11, 12, 15, 20])
+
+if __name__ == '__main__':
+    unittest.main()
diff --git a/algorithms/tests/test_list.py b/algorithms/tests/test_list.py
new file mode 100644
index 0000000..e8c61c4
--- /dev/null
+++ b/algorithms/tests/test_list.py
@@ -0,0 +1,62 @@
+import unittest
+
+import algorithms.list as list
+
+
+class List(unittest.TestCase):
+
+    def setUp(self):
+        pass
+
+    def test_find_max_sub(self):
+        bounds, m = [e for e in list.find_max_sub([-2, 3, -4, 5, 1, -5])]
+        self.assertEqual(bounds, (3, 4))
+        self.assertEqual(m, 6)
+
+    def test_find_int_first_half(self):
+        idx = list.find_int(4, [1, 2, 4, 5, 7, 9])
+        self.assertEqual(idx, 2)
+
+    def test_find_int_second_half(self):
+        idx = list.find_int(7, [1, 2, 4, 5, 7, 9])
+        self.assertEqual(idx, 4)
+
+    def test_find_int_not_found(self):
+        idx = list.find_int(3, [1, 2, 4, 5, 7, 9])
+        self.assertIsNone(idx)
+
+    def test_find_int_single_element_list(self):
+        idx = list.find_int(3, [3, ])
+        self.assertEqual(idx, 0)
+
+    def test_find_int_empty_list(self):
+        idx = list.find_int(3, [])
+        self.assertIsNone(idx)
+
+    def test_merge_sort(self):
+        res = list.merge_sort([3, 4, 1, 5, 0])
+        self.assertListEqual(res, [0, 1, 3, 4, 5])
+
+    def test_merge_sort_duplicates(self):
+        res = list.merge_sort([3, 4, 1, 5, 0, 4])
+        self.assertListEqual(res, [0, 1, 3, 4, 4, 5])
+
+    def test_merge_sort_single_element(self):
+        res = list.merge_sort([3])
+        self.assertListEqual(res, [3])
+
+    def test_quicksort(self):
+        res = list.quicksort([3, 4, 1, 5, 0])
+        self.assertListEqual(res, [0, 1, 3, 4, 5])
+
+    def test_quicksort_duplicates(self):
+        res = list.quicksort([3, 4, 1, 5, 4, 0, 1])
+        self.assertListEqual(res, [0, 1, 1, 3, 4, 4, 5])
+
+    def test_quicksort_single_element(self):
+        res = list.quicksort([3])
+        self.assertListEqual(res, [3])
+
+
+if __name__ == '__main__':
+    unittest.main()

From f1860fe6d41c7515613e59b78411e082e3d9fb33 Mon Sep 17 00:00:00 2001
From: Laurent Luce <laurentluce49@yahoo.com>
Date: Fri, 29 Jan 2021 20:05:11 -0500
Subject: [PATCH 14/16] Updated README to match the current list of algos.

---
 README.md | 8 ++++++++
 1 file changed, 8 insertions(+)

diff --git a/README.md b/README.md
index 77f1a8b..85c29c2 100644
--- a/README.md
+++ b/README.md
@@ -19,6 +19,14 @@ String
 Generators
   - Permutations.
 
+Lists
+  - Find integer using binary search.
+  - Find subset with max sum.
+  - Merge sort.
+  - Quicksort.
+
+Binary tree
+
 ### Tests
 
     $ ./pants test ::

From e565d7316a766a8f3884b40e635e5248b5c70933 Mon Sep 17 00:00:00 2001
From: Laurent Luce <laurentluce49@yahoo.com>
Date: Fri, 29 Jan 2021 20:05:22 -0500
Subject: [PATCH 15/16] Linting.

---
 algorithms/list.py                           | 48 ++++++++++----------
 algorithms/tests/test_a_star_path_finding.py |  1 +
 algorithms/tests/test_binary_tree.py         |  1 +
 3 files changed, 26 insertions(+), 24 deletions(-)

diff --git a/algorithms/list.py b/algorithms/list.py
index 86fb40f..ce7e1c8 100644
--- a/algorithms/list.py
+++ b/algorithms/list.py
@@ -1,45 +1,45 @@
-def find_int(i, l):
+def find_int(i, lst):
     """Find integer in a sorted list.
 
     Example: 4 in [1, 3, 4, 6, 7, 9] -> 2
     @param i integer to find.
-    @param l sorted list.
+    @param lst sorted list.
     @returns index if found, None if not.
     """
-    if l:
-        p_idx = len(l) / 2
-        p = l[p_idx]
+    if lst:
+        p_idx = len(lst) / 2
+        p = lst[p_idx]
         if i == p:
             return p_idx
-        elif len(l) == 1:
+        elif len(lst) == 1:
             return
         elif i < p:
-            res = find_int(i, l[:p_idx])
+            res = find_int(i, lst[:p_idx])
             if res:
                 return res
         elif i > p:
-            res = find_int(i, l[p_idx:])
+            res = find_int(i, lst[p_idx:])
             if res:
                 return res + p_idx
 
 
-def find_max_sub(l):
+def find_max_sub(lst):
     """Find subset with higest sum.
 
     Example: [-2, 3, -4, 5, 1, -5] -> (3,4), 6
-    @param l list
+    @param lst list
     @returns subset bounds and highest sum
     """
     # max sum
-    max = l[0]
+    max = lst[0]
     # current sum
     m = 0
     # max sum subset bounds
     bounds = (0, 0)
     # current subset start
     s = 0
-    for i in range(len(l)):
-        m += l[i]
+    for i in range(len(lst)):
+        m += lst[i]
         if m > max:
             max = m
             bounds = (s, i)
@@ -49,7 +49,7 @@ def find_max_sub(l):
     return bounds, max
 
 
-def merge_sort(l):
+def merge_sort(lst):
     """Sort list using merge sort.
 
     Complexity: O(n log n)
@@ -86,32 +86,32 @@ def merge(l1, l2):
 
         return res
 
-    length = len(l)
+    length = len(lst)
     if length <= 1:
-        return l
+        return lst
     mid = length / 2
-    h1 = merge_sort(l[:mid])
-    h2 = merge_sort(l[mid:])
+    h1 = merge_sort(lst[:mid])
+    h2 = merge_sort(lst[mid:])
 
     return merge(h1, h2)
 
 
-def quicksort(l):
+def quicksort(lst):
     """Sort list using quick sort.
 
     Complexity: O(n log n).  Worst: O(n2)
 
-    @param l list to sort.
+    @param lst list to sort.
     @returns sorted list.
     """
-    if len(l) <= 1:
-        return l
+    if len(lst) <= 1:
+        return lst
 
-    pivot = l[0]
+    pivot = lst[0]
     less = []
     equal = []
     greater = []
-    for e in l:
+    for e in lst:
         if e < pivot:
             less.append(e)
         elif e == pivot:
diff --git a/algorithms/tests/test_a_star_path_finding.py b/algorithms/tests/test_a_star_path_finding.py
index c2e991e..396388d 100644
--- a/algorithms/tests/test_a_star_path_finding.py
+++ b/algorithms/tests/test_a_star_path_finding.py
@@ -32,5 +32,6 @@ def test_maze_no_solution(self):
         a.init_grid(6, 6, walls, (0, 0), (5, 5))
         self.assertIsNone(a.solve())
 
+
 if __name__ == '__main__':
     unittest.main()
diff --git a/algorithms/tests/test_binary_tree.py b/algorithms/tests/test_binary_tree.py
index 0ec3397..ca0eede 100644
--- a/algorithms/tests/test_binary_tree.py
+++ b/algorithms/tests/test_binary_tree.py
@@ -161,5 +161,6 @@ def test_tree_data(self):
         self.assertEqual([e for e in self.root.tree_data()],
                          [3, 5, 7, 10, 11, 12, 15, 20])
 
+
 if __name__ == '__main__':
     unittest.main()

From 6a82a4c6c594508436835c8127d8d2f1b931a300 Mon Sep 17 00:00:00 2001
From: Tim Gates <tim.gates@iress.com>
Date: Sat, 4 Sep 2021 08:08:35 +1000
Subject: [PATCH 16/16] docs: fix simple typo, higest -> highest

There is a small typo in algorithms/list.py.

Should read `highest` rather than `higest`.
---
 algorithms/list.py | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/algorithms/list.py b/algorithms/list.py
index ce7e1c8..1546904 100644
--- a/algorithms/list.py
+++ b/algorithms/list.py
@@ -24,7 +24,7 @@ def find_int(i, lst):
 
 
 def find_max_sub(lst):
-    """Find subset with higest sum.
+    """Find subset with highest sum.
 
     Example: [-2, 3, -4, 5, 1, -5] -> (3,4), 6
     @param lst list