From 7fd1b6a7046759d40d7201f03f286109cc53ce43 Mon Sep 17 00:00:00 2001
From: wes <wjak56@gmail.com>
Date: Sat, 1 Jul 2017 12:25:14 -0400
Subject: [PATCH] first commit

---
 bfs.py          | 30 ++++++++++++++++++++++++
 bst.py          | 48 ++++++++++++++++++++++++++++++++++++++
 fib.hs          | 16 +++++++++++++
 intersection.py | 23 ++++++++++++++++++
 palindrome.py   | 19 +++++++++++++++
 pascal.hs       | 10 ++++++++
 pascal.py       | 14 +++++++++++
 phone.py        | 37 +++++++++++++++++++++++++++++
 regions.py      | 62 +++++++++++++++++++++++++++++++++++++++++++++++++
 reverse_list.py | 39 +++++++++++++++++++++++++++++++
 10 files changed, 298 insertions(+)
 create mode 100755 bfs.py
 create mode 100755 bst.py
 create mode 100755 fib.hs
 create mode 100755 intersection.py
 create mode 100755 palindrome.py
 create mode 100755 pascal.hs
 create mode 100755 pascal.py
 create mode 100755 phone.py
 create mode 100755 regions.py
 create mode 100755 reverse_list.py

diff --git a/bfs.py b/bfs.py
new file mode 100755
index 0000000..e15773d
--- /dev/null
+++ b/bfs.py
@@ -0,0 +1,30 @@
+#! /usr/bin/env python3
+
+# breadth first traversal of a binary tree
+
+from collections import deque
+
+class Branch:
+    def __init__(self, v, left, right):
+        self.v = v
+        self.left = left
+        self.right = right
+
+def bfs(tree, process):
+    nodes = deque([tree])
+    current_node = None
+    while nodes:
+        current_nodes = list(nodes)
+        for node in current_nodes:
+            current_node = node
+            process(current_node.v)
+            nodes.popleft()
+            if not current_node.left is None:
+                nodes.appendleft(current_node.left)
+            if not node.right is None:
+                nodes.appendleft(current_node.right)
+
+test = Branch(1, Branch(2, Branch(3, None, None), Branch(4, None, None)),
+                 Branch(5, None, None))
+
+bfs(test, print)
diff --git a/bst.py b/bst.py
new file mode 100755
index 0000000..cff4d36
--- /dev/null
+++ b/bst.py
@@ -0,0 +1,48 @@
+#! /usr/bin/env python2
+
+from random import randint
+from pprint import PrettyPrinter
+
+# Construct a binary search tree
+# Also create a function to search it
+
+pp = PrettyPrinter(indent=4)
+
+class Branch:
+    def __init__(self, left, value, right):
+        self.value = value
+        self.left = left
+        self.right = right
+
+    def __repr__(self):
+        return "(%s) %s (%s)" % (repr(self.left), self.value, repr(self.right))
+
+def split(xs):
+    l = len(xs) / 2
+    return (xs[0:l], xs[l], xs[l+1:])
+
+def bst(xs):
+    if not xs:
+        return None
+    left, middle, right = split(xs)
+    return Branch(bst(left), middle, bst(right))
+
+def makeBST(xs):
+    return bst(sorted(xs))
+
+def findBST(tree, x):
+    if tree is None:
+        return None
+    print tree.value
+    if tree.value == x:
+        return tree
+    if x < tree.value:
+        return findBST(tree.left, x)
+    else:
+        return findBST(tree.right, x)
+
+test = [randint(1,50) for _ in range(20)]
+
+print test
+print "finding %s" % test[4]
+print findBST(makeBST(test), test[4])
diff --git a/fib.hs b/fib.hs
new file mode 100755
index 0000000..9f1f396
--- /dev/null
+++ b/fib.hs
@@ -0,0 +1,16 @@
+#! /usr/bin/env runghc
+
+-- get the nth fibonnaci number in linear time
+
+import qualified Data.List as L
+
+fibs = L.unfoldr
+        (\(prev, cur) -> Just (prev, (cur, prev+cur)))
+        (0, 1)
+
+getNthFib n = fibs !! n
+
+main = do
+  print $ getNthFib 1
+  print $ getNthFib 7
+  print $ getNthFib 100
diff --git a/intersection.py b/intersection.py
new file mode 100755
index 0000000..cd7d71d
--- /dev/null
+++ b/intersection.py
@@ -0,0 +1,23 @@
+#! /usr/bin/env python2
+
+# find the intersection of two lists including duplicate values
+
+from collections import defaultdict
+
+def frequencies(xs):
+    freqs = defaultdict(int)
+    for x in xs:
+        freqs[x] += 1
+    return freqs
+
+def intersection(fs1, fs2):
+    xs = []
+    for k, v in fs1.iteritems():
+        n = min(v, fs2[k])
+        xs.extend([k for _ in xrange(n)])
+    return xs
+
+fs1 = frequencies([1,4,2,6,10,4,4])
+fs2 = frequencies([7,4,9,10,20,4,10])
+
+print intersection(fs1, fs2)
diff --git a/palindrome.py b/palindrome.py
new file mode 100755
index 0000000..3b0e7fd
--- /dev/null
+++ b/palindrome.py
@@ -0,0 +1,19 @@
+#! /usr/bin/env python2
+
+# check if a word is palindromic without reversing it
+
+def isPalindrome(word):
+    end = len(word)
+    start = 0
+    foo = True
+    while start < end+1:
+        left = word[start]
+        right = word[end-1]
+        if left != right:
+            foo = False
+            break
+        start += 1
+        end -= 1
+    return foo
+
+print isPalindrome("wwaabbaawwz")
diff --git a/pascal.hs b/pascal.hs
new file mode 100755
index 0000000..bc7c866
--- /dev/null
+++ b/pascal.hs
@@ -0,0 +1,10 @@
+module Main where
+
+-- find the rows of pascal's triangle
+
+choose n 0 = 1
+choose n k = (choose n (k-1)) * (n-k) `div` k
+
+pascal n = [choose n i | i <- [0..n-1]]
+
+main = mapM_ print $ map pascal [1..100]
diff --git a/pascal.py b/pascal.py
new file mode 100755
index 0000000..488fadb
--- /dev/null
+++ b/pascal.py
@@ -0,0 +1,14 @@
+#! /usr/bin/env python2
+
+# find the rows of pascal's triangle
+
+def choose(n, k):
+    if k == 0:
+        return 1
+    return choose(n, k-1) * (n-k) / k
+
+def pascal(n):
+    return [choose(n, i) for i in xrange(0, n)]
+
+for i in xrange(1, 11):
+    print pascal(i)
diff --git a/phone.py b/phone.py
new file mode 100755
index 0000000..7fc2667
--- /dev/null
+++ b/phone.py
@@ -0,0 +1,37 @@
+#! /usr/bin/env python2
+
+# find all possible permutations of a sequence of phone pad digits (other than 1 and 0)
+
+from itertools import chain
+
+mappings = {
+        2 : "ABC",
+        3 : "DEF",
+        4 : "GHI",
+        5 : "JKL",
+        6 : "MNO",
+        7 : "PQRS",
+        8 : "TUV",
+        9 : "WXYZ"
+    }
+
+def generate(letter, letters):
+    return [letter + c for c in letters]
+
+def genWords(one, two):
+    return list(chain.from_iterable([generate(c, two) for c in one]))
+
+def genAll(lettersets):
+    if len(lettersets) == 1:
+        return lettersets
+
+    first = lettersets[0]
+    rest = lettersets[1:]
+    return [genWords(first, ls) for ls in genAll(rest)]
+
+def numToWords(num):
+    lettersets = [mappings[int(n)] for n in num]
+    return genAll(lettersets)[0]
+
+for num in numToWords("353346"):
+    print num
diff --git a/regions.py b/regions.py
new file mode 100755
index 0000000..6f14730
--- /dev/null
+++ b/regions.py
@@ -0,0 +1,62 @@
+#! /usr/bin/env python2
+
+# counts the number of regions in a matrix
+# vertically and horizontally connected
+# e.g.
+# [1, 0, 1, 1]
+# [0, 1, 0, 0]
+# [1, 1, 0, 1]
+#  has 4 regions
+
+class Patch(object):
+    def __init__(self, visited, value):
+        self.visited = visited
+        self.value = value
+
+    def __repr__(self):
+        return "visited = %s, value = %s" % (self.visited, self.value)
+
+def initialize(region):
+    for row in region:
+        yield [Patch(visited=False, value=field) for field in row]
+
+testregion = list(initialize([
+        [True, False, True, True],
+        [False, True, False, False],
+        [True, True, False, True]
+]))
+
+columns = len(testregion[0])
+rows = len(testregion)
+
+def exploreField(region, x, y):
+
+    # check if we've reached the edge of the matrix
+    if (x < 0 or y < 0):
+        return True
+    try:
+        if region[y][x].visited or not region[y][x].value:
+            return True
+    except IndexError:
+        return True
+
+    region[y][x].visited = True
+
+    exploreField(region, y+1, x)
+    exploreField(region, y-1, x)
+    exploreField(region, y, x+1)
+    exploreField(region, y, x-1)
+
+count = 0
+
+for y, row in enumerate(testregion):
+    for x, patch in enumerate(row):
+
+        # if a patch is both unvisited and true
+        # this means exploreField will eliminate it
+        # so it counts as one region
+        if not patch.visited and patch.value:
+            count += 1
+        exploreField(testregion, x, y)
+
+print count
diff --git a/reverse_list.py b/reverse_list.py
new file mode 100755
index 0000000..02dec17
--- /dev/null
+++ b/reverse_list.py
@@ -0,0 +1,39 @@
+#! /usr/bin/env python3
+
+# reverse a linked list
+
+class LinkedList:
+    def __init__(self, head, tail):
+        self.head = head
+        self.tail = tail
+
+    def __repr__(self):
+        return "%s%s" % (self.head, "" if self.tail is None else ",%s" % repr(self.tail))
+
+def cons(x, xs):
+    return LinkedList(x, xs)
+
+xs = cons(1, cons(2, cons(3, cons(4, cons(5, None)))))
+
+def push(x, xs):
+    prev = xs.head
+    xs.head = x
+    xs.tail = cons(prev, xs.tail)
+
+def reverseLinkedList(xs):
+    current = xs.head
+    rest = xs.tail
+    revd = None
+    while True:
+        if revd is None:
+            revd = cons(current, None)
+        else:
+            push(current, revd)
+        if rest is None:
+            break
+        current = rest.head
+        rest = rest.tail
+
+    return revd
+
+print(reverseLinkedList(xs))