Update links

Bumps [sqlalchemy](https://github.com/sqlalchemy/sqlalchemy) from 0.9.7 to 1.3.0.
- [Release notes](https://github.com/sqlalchemy/sqlalchemy/releases)
- [Changelog](https://github.com/sqlalchemy/sqlalchemy/blob/main/CHANGES.rst)
- [Commits](https://github.com/sqlalchemy/sqlalchemy/commits)

---
updated-dependencies:
- dependency-name: sqlalchemy
  dependency-type: direct:production
...

Signed-off-by: dependabot[bot] <support@github.com>
Co-authored-by: dependabot[bot] <49699333+dependabot[bot]@users.noreply.github.com>

.gitignore

@@ -1,39 +0,0 @@
-*.py[cod]
-*~
-
-# C extensions
-*.so
-
-# Packages
-*.egg
-*.egg-info
-dist
-build
-eggs
-parts
-bin
-var
-sdist
-develop-eggs
-.installed.cfg
-lib
-lib64
-
-# Installer logs
-pip-log.txt
-
-# Unit test / coverage reports
-.coverage
-.tox
-nosetests.xml
-
-# Translations
-*.mo
-
-# Mr Developer
-.mr.developer.cfg
-.project
-.pydevproject
-
-# PyCharm
-.idea

MY_BOOK/ebook_src/abstract_structures/HashTableClass.py

@@ -0,0 +1,41 @@
+#!/usr/bin/env python
+
+__author__ = "bt3"
+
+
+class HashTable(object):
+    def __init__(self, slots=10):
+        self.slots = slots
+        self.table = []
+        self.create_table()
+
+    def hash_key(self, value):
+        return hash(value)%self.slots
+
+    def create_table(self):
+        for i in range(self.slots):
+            self.table.append([])
+
+    def add_item(self, value):
+        key = self.hash_key(value)
+        self.table[key].append(value)
+
+    def print_table(self):
+        for key in range(len(self.table)):
+            print "Key is %s, value is %s." %(key, self.table[key])
+
+    def find_item(self, item):
+        pos = self.hash_key(item)
+        if item in self.table[pos]:
+            return True
+        else:
+            return False
+
+if __name__ == '__main__':
+    dic = HashTable(5)
+    for i in range(1, 40, 2):
+        dic.add_item(i)
+
+    dic.print_table()
+    assert(dic.find_item(20) == False)
+    assert(dic.find_item(21) == True)

MY_BOOK/ebook_src/abstract_structures/QueueClass.py

@@ -0,0 +1,47 @@
+#!/usr/bin/env python
+# Time: 5 min
+
+__author__ = "bt3"
+
+
+class Queue(object):
+    def __init__(self):
+        self.enq = []
+        self.deq = []
+
+    def enqueue(self, item):
+        return self.enq.append(item)
+
+    def deque(self):
+        if not self.deq:
+            while self.enq:
+                self.deq.append(self.enq.pop())
+        return self.deq.pop()
+
+    def peak(self):
+        if not self.deq:
+            while self.enq:
+                self.deq.append(self.enq.pop())
+        if self.deq:
+            return self.deq[-1]
+
+    def size(self):
+        return len(self.enq) + len(self.deq)
+
+    def isempty(self):
+        return not (self.enq + self.deq)
+
+if __name__ == '__main__':
+    q = Queue()
+    for i in range(1,11):
+        q.enqueue(i)
+    print 'Size:',  q.size()
+    print 'Is empty?', q.isempty()
+    print 'Peak: ', q.peak()
+    print
+    print 'Dequeuing...'
+    for i in range(10):
+        print q.deque()
+    print 'Size:',  q.size()
+    print 'Is empty?', q.isempty()
+    print 'Peak: ', q.peak()

MY_BOOK/ebook_src/abstract_structures/Stack.py

@@ -0,0 +1,63 @@
+#!/usr/bin/env python
+
+__author__ = "bt3"
+
+
+class Stack(object):
+    def __init__(self):
+        self.content = []
+        self.min_array = []
+        self.min = float('inf')
+
+    def push(self, value):
+        if value < self.min:
+            self.min = value
+
+        self.content.append(value)
+        self.min_array.append(self.min)
+
+    def pop(self):
+        if self.content:
+            value = self.content.pop()
+            self.min_array.pop()
+            if self.min_array:
+                self.min = self.min_array[-1]
+            return value
+        else:
+            return 'Empty List. '
+
+    def find_min(self):
+        if self.min_array:
+            return self.min_array[-1]
+        else:
+            return 'No min value for empty list.'
+
+    def size(self):
+        return len(self.content)
+
+    def isEmpty(self):
+        return not bool(self.content)
+
+    def peek(self):
+        if self.content:
+            return self.content[-1]
+        else:
+            print('Stack is empty.')
+
+
+    def __repr__(self):
+        return '{}'.format(self.content)
+
+
+if __name__ == '__main__':
+    q = Stack()
+
+    for i in range(15,20):
+        q.push(i)
+    for i in range(10,5,-1):
+        q.push(i)
+
+
+
+    for i in range(1, 13):
+        print q.pop(), q.find_min()

MY_BOOK/ebook_src/abstract_structures/heap/find_N_largest_smallest_items_seq.py

@@ -1,13 +1,13 @@
-#!/usr/bin/python3
-# mari von steinkirch @2013
-# steinkirch at gmail
+#!/usr/bin/env python
+
+__author__ = "bt3"
 
 import heapq
 
 def find_N_largest_items_seq(seq, N):
     ''' find the N largest items in a sequence '''
     return heapq.nlargest(N,seq)
-    
+
 def find_N_smallest_items_seq(seq, N):
     ''' find the N smallest items in a sequence '''
     return heapq.nsmallest(N, seq)
@@ -18,7 +18,7 @@ def find_smallest_items_seq_heap(seq):
     ''' pops the smallest item, O(logN) '''
     heapq.heapify(seq)
     return heapq.heappop(seq)
-   
+
 def find_smallest_items_seq(seq):
     '''  if it is only one item, min() is faster '''
     return min(seq)
@@ -26,7 +26,7 @@ def find_smallest_items_seq(seq):
 def find_N_smallest_items_seq_sorted(seq, N):
     '''  N ~ len(seq), better sort instead'''
     return sorted(seq)[:N]
-    
+
 def find_N_largest_items_seq_sorted(seq, N):
     '''  N ~ len(seq), better sort instead'''
     return sorted(seq)[len(seq)-N:]
@@ -41,7 +41,7 @@ def test_find_N_largest_smallest_items_seq(module_name='this module'):
     assert(find_N_smallest_items_seq_sorted(seq, N) == [1,2,3])
     assert(find_smallest_items_seq(seq) == 1)
     assert(find_smallest_items_seq_heap(seq) == 1)
-        
+
     s = 'Tests in {name} have {con}!'
     print(s.format(name=module_name, con='passed'))
 

MY_BOOK/ebook_src/abstract_structures/heap/heapify.py

@@ -1,13 +1,13 @@
-#!/usr/bin/python3
-# mari von steinkirch @2013
-# steinkirch at gmail
+#!/usr/bin/env python
+
+__author__ = "bt3"
 
 class Heapify(object):
     def __init__(self, data=None):
         self.data = data or []
         for i in range(len(data)//2, -1, -1):
             self.__max_heapify__(i)
-    
+
     def __repr__(self):
         return '{}'.format(self.data)
 
@@ -19,12 +19,12 @@ class Heapify(object):
 
     def right_child(self, i):
         return (i << 1) + 2 # +2 instead of +1 because it's 0-indexed.
- 
+
     def __max_heapify__(self, i):
         largest = i
         left = self.left_child(i)
         right = self.right_child(i)
-        n = len(self.data) 
+        n = len(self.data)
         largest = (left < n and self.data[left] > self.data[i]) and left or i
         largest = (right < n and self.data[right] > self.data[largest]) and right or largest
         if i is not largest:
@@ -44,7 +44,6 @@ def test_Heapify():
     l1 = [3, 2, 5, 1, 7, 8, 2]
     h = Heapify(l1)
     assert(h.extract_max() == 8)
-    print ("Tests Passed!")
 
 if __name__ == '__main__':
     test_Heapify()

MY_BOOK/ebook_src/abstract_structures/heap/merge_sorted_seqs.py

@@ -1,6 +1,6 @@
-#!/usr/bin/python3
-# mari von steinkirch @2013
-# steinkirch at gmail
+#!/usr/bin/env python
+
+__author__ = "bt3"
 
 import heapq
 
@@ -19,9 +19,7 @@ def test_merge_sorted_seq(module_name='this module'):
     seq2 = [2, 3, 4, 5, 6, 7, 9]
     seq3 = seq1 + seq2
     assert(merge_sorted_seqseq1, seq2) == sorted(seq3))
-        
-    s = 'Tests in {name} have {con}!'
-    print(s.format(name=module_name, con='passed'))
+
 
 
 if __name__ == '__main__':

MY_BOOK/ebook_src/abstract_structures/heap/priority_queue.py

@@ -1,6 +1,6 @@
-#!/usr/bin/python3
-# mari von steinkirch @2013
-# steinkirch at gmail
+#!/usr/bin/env python
+
+__author__ = "bt3"
 
 import heapq
 
@@ -9,11 +9,11 @@ class PriorityQueue(object):
     def __init__(self):
         self._queue = []
         self._index = 0 # comparying same priority level
-    
+
     def push(self, item, priority):
-        heapq.heappush(self._queue, (-priority, self._index, item)) 
+        heapq.heappush(self._queue, (-priority, self._index, item))
         self._index += 1
-    
+
     def pop(self):
         return heapq.heappop(self._queue)[-1]
 
@@ -32,7 +32,6 @@ def test_PriorityQueue():
     q.push(Item('test2'), 4)
     q.push(Item('test3'), 3)
     assert(str(q.pop()) == "Item('test2')")
-    print('Tests passed!'.center(20,'*'))
 
 
 if __name__ == '__main__':

MY_BOOK/ebook_src/abstract_structures/linked_list/circular_ll.py

@@ -1,8 +1,6 @@
-#!/usr/bin/python
-
-__author__ = "Mari Wahl"
-__email__ = "marina.w4hl@gmail.com"
+#!/usr/bin/env python
 
+__author__ = "bt3"
 
 
 ''' implement a function to see whether a linked list is circular.

MY_BOOK/ebook_src/abstract_structures/linked_list/double_linked_list_fifo.py

@@ -1,7 +1,6 @@
-#!/usr/bin/python
+#!/usr/bin/env python
 
-__author__ = "Mari Wahl"
-__email__ = "marina.w4hl@gmail.com"
+__author__ = "bt3"
 
 ''' Implement a double-linked list, which is very simple, we just need inherits
 from a Linked List Class and  add an attribute for previous.'''
@@ -18,7 +17,6 @@ class dNode(object):
 
 class dLinkList(LinkedListFIFO):
 
-    # print each node's value, starting from tail
     def printListInverse(self):
         node = self.tail
         while node:
@@ -28,8 +26,6 @@ class dLinkList(LinkedListFIFO):
             except:
                 break
 
-    # add a node in a position different from head,
-    # ie, in the end of the list
     def _add(self, value):
         self.length += 1
         node = dNode(value)
@@ -38,14 +34,12 @@ class dLinkList(LinkedListFIFO):
             node.previous = self.tail
         self.tail = node
 
-    # delete a node in some position
     def _delete(self, node):
         self.length -= 1
         node.previous.pointer = node.pointer
         if not node.pointer:
             self.tail = node.previous
 
-    # locate node with some index
     def _find(self, index):
         node = self.head
         i = 0
@@ -66,11 +60,6 @@ class dLinkList(LinkedListFIFO):
                 print('Node with index {} not found'.format(index))
 
 
-
-
-
-
-
 if __name__ == '__main__':
 
     from collections import Counter

MY_BOOK/ebook_src/abstract_structures/linked_list/find_kth_from_the_end.py

@@ -1,7 +1,7 @@
-#!/usr/bin/python
+#!/usr/bin/env python
+
+__author__ = "bt3"
 
-__author__ = "Mari Wahl"
-__email__ = "marina.w4hl@gmail.com"
 
 ''' Find the mth-to-last element of a linked list.
     One option is having two pointers, separated by m. P1 start at the roots

MY_BOOK/ebook_src/abstract_structures/linked_list/linked_list_fifo.py

@@ -1,15 +1,12 @@
-#!/usr/bin/python
+#!/usr/bin/env python
 
-__author__ = "Mari Wahl"
-__email__ = "marina.w4hl@gmail.com"
+__author__ = "bt3"
 
 ''' A class for a linked list that has the nodes in a FIFO order (such as a queue)'''
 
 
 from node import Node
 
-
-
 class LinkedListFIFO(object):
 
     def __init__(self):
@@ -17,32 +14,24 @@ class LinkedListFIFO(object):
         self.length = 0
         self.tail = None # this is different from ll lifo
 
-
-    # print each node's value, starting from the head
     def _printList(self):
         node = self.head
         while node:
             print(node.value)
             node = node.pointer
 
-    # add a node in the first position
-    # read will never be changed again while not empty
     def _addFirst(self, value):
         self.length = 1
         node = Node(value)
         self.head = node
         self.tail = node
 
-    # delete a node in the first position, ie
-    # when there is no previous node
     def _deleteFirst(self):
         self.length = 0
         self.head = None
         self.tail = None
         print('The list is empty.')
 
-    # add a node in a position different from head,
-    # ie, in the end of the list
     def _add(self, value):
         self.length += 1
         node = Node(value)
@@ -50,15 +39,12 @@ class LinkedListFIFO(object):
             self.tail.pointer = node
         self.tail = node
 
-
-    # add nodes in general
     def addNode(self, value):
         if not self.head:
             self._addFirst(value)
         else:
             self._add(value)
 
-    # locate node with some index
     def _find(self, index):
         prev = None
         node = self.head
@@ -69,7 +55,6 @@ class LinkedListFIFO(object):
             i += 1
         return node, prev, i
 
-    # delete nodes in general
     def deleteNode(self, index):
         if not self.head or not self.head.pointer:
             self._deleteFirst()
@@ -87,9 +72,6 @@ class LinkedListFIFO(object):
                 print('Node with index {} not found'.format(index))
 
 
-
-
-
 if __name__ == '__main__':
     ll = LinkedListFIFO()
     for i in range(1, 5):

MY_BOOK/ebook_src/abstract_structures/linked_list/linked_list_lifo.py

@@ -1,9 +1,6 @@
-#!/usr/bin/python
-
-__author__ = "Mari Wahl"
-__email__ = "marina.w4hl@gmail.com"
-
+#!/usr/bin/env python
 
+__author__ = "bt3"
 
 
 ''' Implement a unordered linked list, i.e. a LIFO linked list (like a stack) '''
@@ -16,15 +13,12 @@ class LinkedListLIFO(object):
         self.head = None
         self.length = 0
 
-
-    # print each node's value, starting from the head
     def _printList(self):
         node = self.head
         while node:
             print(node.value)
             node = node.pointer
 
-    # delete a node, given the previous node
     def _delete(self, prev, node):
         self.length -= 1
         if not prev:
@@ -32,14 +26,10 @@ class LinkedListLIFO(object):
         else:
             prev.pointer = node.pointer
 
-    # add a new node, pointing to the previous node
-    # in the head
     def _add(self, value):
         self.length += 1
         self.head = Node(value, self.head)
 
-
-    # locate node with some index
     def _find(self, index):
         prev = None
         node = self.head
@@ -50,7 +40,6 @@ class LinkedListLIFO(object):
             i += 1
         return node, prev, i
 
-    # locate node by value
     def _find_by_value(self, value):
         prev = None
         node = self.head
@@ -63,8 +52,6 @@ class LinkedListLIFO(object):
                 node = node.pointer
         return node, prev, found
 
-
-    # find and delete a node by index
     def deleteNode(self, index):
         node, prev, i = self._find(index)
         if index == i:
@@ -72,8 +59,6 @@ class LinkedListLIFO(object):
         else:
             print('Node with index {} not found'.format(index))
 
-
-    # find and delete a node by value
     def deleteNodeByValue(self, value):
         node, prev, found = self._find_by_value(value)
         if found:

MY_BOOK/ebook_src/abstract_structures/linked_list/node.py

@@ -1,8 +1,6 @@
-#!/usr/bin/python
-
-__author__ = "Mari Wahl"
-__email__ = "marina.w4hl@gmail.com"
+#!/usr/bin/env python
 
+__author__ = "bt3"
 
 class Node(object):
     def __init__(self, value=None, pointer=None):

MY_BOOK/ebook_src/abstract_structures/linked_list/part_linked_list.py

@@ -1,7 +1,6 @@
-#!/usr/bin/python
+#!/usr/bin/env python
 
-__author__ = "Mari Wahl"
-__email__ = "marina.w4hl@gmail.com"
+__author__ = "bt3"
 
 ''' This function divides a linked list in a value, where everything smaller than this value
     goes to the front, and everything large goes to the back:'''

MY_BOOK/ebook_src/abstract_structures/linked_list/sum_linked_list.py

@@ -1,7 +1,6 @@
-#!/usr/bin/python
+#!/usr/bin/env python
 
-__author__ = "Mari Wahl"
-__email__ = "marina.w4hl@gmail.com"
+__author__ = "bt3"
 
 ''' Supposing two linked lists representing numbers, such that in each of their
     nodes they carry one digit. This function sums the two numbers that these

MY_BOOK/ebook_src/abstract_structures/queues/animal_shelter.py

@@ -1,7 +1,6 @@
-#!/usr/bin/python
+#!/usr/bin/env python
 
-__author__ = "Mari Wahl"
-__email__ = "marina.w4hl@gmail.com"
+__author__ = "bt3"
 
 
 """ A class for an animal shelter with two queues"""

MY_BOOK/ebook_src/abstract_structures/queues/deque.py

@@ -1,7 +1,6 @@
-#!/usr/bin/python
+#!/usr/bin/env python
 
-__author__ = "Mari Wahl"
-__email__ = "marina.w4hl@gmail.com"
+__author__ = "bt3"
 
 ''' a class for a double ended queue (also inefficient) '''
 

MY_BOOK/ebook_src/abstract_structures/queues/linked_queue.py

@@ -1,7 +1,6 @@
-#!/usr/bin/python
+#!/usr/bin/env python
 
-__author__ = "Mari Wahl"
-__email__ = "marina.w4hl@gmail.com"
+__author__ = "bt3"
 
 ''' Queue acts as a container for nodes (objects) that are inserted and removed according FIFO'''
 

MY_BOOK/ebook_src/abstract_structures/queues/palindrome_checker_with_deque.py

@@ -1,17 +1,19 @@
-#!/usr/bin/python
+#!/usr/bin/env python
+
+__author__ = "bt3"
+
+
+""" Using our deque class and Python's deque class """
 
-__author__ = "Mari Wahl"
-__email__ = "marina.w4hl@gmail.com"
 
 import string
 import collections
 
 from deque import Deque
 
+
 STRIP = string.whitespace + string.punctuation + "\"'"
 
-
-""" Using our deque class and Python's deque class """
 def palindrome_checker_with_deque(str1):
 
     d1 = Deque()

MY_BOOK/ebook_src/abstract_structures/queues/queue.py

@@ -1,10 +1,6 @@
-#!/usr/bin/python
+#!/usr/bin/env python
 
-__author__ = "Mari Wahl"
-__email__ = "marina.w4hl@gmail.com"
-
-
-''' an example of a queue implemented from 2 stacks '''
+__author__ = "bt3"
 
 
 class Queue(object):
@@ -13,17 +9,13 @@ class Queue(object):
         self.in_stack = []
         self.out_stack = []
 
-
-    # basic methods
     def _transfer(self):
         while self.in_stack:
             self.out_stack.append(self.in_stack.pop())
 
-
     def enqueue(self, item):
         return self.in_stack.append(item)
 
-
     def dequeue(self):
         if not self.out_stack:
             self._transfer()
@@ -32,11 +24,9 @@ class Queue(object):
         else:
             return "Queue empty!"
 
-
     def size(self):
         return len(self.in_stack) + len(self.out_stack)
 
-
     def peek(self):
         if not self.out_stack:
             self._transfer()
@@ -54,9 +44,7 @@ class Queue(object):
             return "Queue empty!"
 
     def isEmpty(self):
-        return not ((bool(self.in_stack) or bool(self.out_stack)))
-
-
+        return not (bool(self.in_stack) or bool(self.out_stack))
 
 
 if __name__ == '__main__':

MY_BOOK/ebook_src/abstract_structures/stacks/dec2bin_with_stack.py

@@ -1,7 +1,7 @@
-#!/usr/bin/python
+#!/usr/bin/env python
+
+__author__ = "bt3"
 
-__author__ = "Mari Wahl"
-__email__ = "marina.w4hl@gmail.com"
 
 '''transform a decimal number to a binary number with a stack '''
 

MY_BOOK/ebook_src/abstract_structures/stacks/linked_stack.py

@@ -1,13 +1,11 @@
-#!/usr/bin/python
+#!/usr/bin/env python
 
-__author__ = "Mari Wahl"
-__email__ = "marina.w4hl@gmail.com"
+__author__ = "bt3"
 
 
 """ A stack made of linked list"""
 
 
-
 class Node(object):
     def __init__(self, value=None, pointer=None):
         self.value = value

MY_BOOK/ebook_src/abstract_structures/stacks/reverse_string_with_stack.py

@@ -1,7 +1,7 @@
-#!/usr/bin/python
+#!/usr/bin/env python
+
+__author__ = "bt3"
 
-__author__ = "Mari Wahl"
-__email__ = "marina.w4hl@gmail.com"
 
 ''' Uses a stack to reverse a string '''
 

MY_BOOK/ebook_src/abstract_structures/stacks/set_of_stacks.py

@@ -1,7 +1,6 @@
-#!/usr/bin/python
+#!/usr/bin/env python
 
-__author__ = "Mari Wahl"
-__email__ = "marina.w4hl@gmail.com"
+__author__ = "bt3"
 
 """ define a class for a set of stacks """
 

MY_BOOK/ebook_src/abstract_structures/stacks/stack.py

@@ -0,0 +1,65 @@
+#!/usr/bin/env python
+
+# copy of the class ../Stack.py
+
+__author__ = "bt3"
+
+
+class Stack(object):
+    def __init__(self):
+        self.content = []
+        self.min_array = []
+        self.min = float('inf')
+
+    def push(self, value):
+        if value < self.min:
+            self.min = value
+
+        self.content.append(value)
+        self.min_array.append(self.min)
+
+    def pop(self):
+        if self.content:
+            value = self.content.pop()
+            self.min_array.pop()
+            if self.min_array:
+                self.min = self.min_array[-1]
+            return value
+        else:
+            return 'Empty List. '
+
+    def find_min(self):
+        if self.min_array:
+            return self.min_array[-1]
+        else:
+            return 'No min value for empty list.'
+
+    def size(self):
+        return len(self.content)
+
+    def isEmpty(self):
+        return not bool(self.content)
+
+    def peek(self):
+        if self.content:
+            return self.content[-1]
+        else:
+            print('Stack is empty.')
+
+
+    def __repr__(self):
+        return '{}'.format(self.content)
+
+
+if __name__ == '__main__':
+    q = Stack()
+
+    for i in range(15,20):
+        q.push(i)
+    for i in range(10,5,-1):
+        q.push(i)
+
+
+
+    for i in range(1, 13):
+        print q.pop(), q.find_min()

MY_BOOK/ebook_src/abstract_structures/stacks/stack_with_min.py

@@ -1,7 +1,6 @@
-#!/usr/bin/python
+#!/usr/bin/env python
 
-__author__ = "Mari Wahl"
-__email__ = "marina.w4hl@gmail.com"
+__author__ = "bt3"
 
 ''' A stack with a minimum lookup '''
 

MY_BOOK/ebook_src/abstract_structures/stacks/towers_of_hanoi.py

@@ -1,7 +1,7 @@
-#!/usr/bin/python
+#!/usr/bin/env python
+
+__author__ = "bt3"
 
-__author__ = "Mari Wahl"
-__email__ = "marina.w4hl@gmail.com"
 
 
 """ Implement the 'towers of hanoi'"""

MY_BOOK/ebook_src/bitwise_operations/bit_array.py

@@ -1,17 +1,16 @@
-#!/usr/bin/python3
-# mari von steinkirch @2013
-# steinkirch at gmail
+#!/usr/bin/env python
 
-''' Example of how to use a bit array in python as a "counter" dict:
+__author__ = "bt3"
 
+''' Example of how to use a bit array in python as a "counter" dict'''
+
+def print_dupl_ba(l1):
+    '''
     >>> l1 = [0, 1, 2, 3, 4, 2, 6, 7, 8, 9]
     >>> print_dupl_ba(l1)
     2
-'''
+    '''
 
-
-
-def print_dupl_ba(l1):
     bs = bytearray(10)
     for i in range(len(l1)):
         if i == l1[i]:
@@ -22,9 +21,6 @@ def print_dupl_ba(l1):
     return None
 
 
-    
-    
-    
 
 if __name__ == '__main__':
     import doctest

MY_BOOK/ebook_src/bitwise_operations/bitwise.txt

@@ -0,0 +1,33 @@
+				BIT-WISE
+			----------------------
+
+1. To find a number:
+11000101 is 2^0+2^2+2^6+2^7 = 197
+
+
+2. Left shifting:
+	0010 1011 << 4  ---> 1011 000
+
+
+3. Right shifting:
+	0010 1011 >> 4	---> 0000 0010
+	or it can be filled with the copy of the first bit, instead of 0:
+	1011 0010 >> 4  ---> 1111 1011
+
+
+4. XOR can cancels out:
+15 ^ 12 ^ 15 = 12
+
+
+5. 2^x:
+	left-shift 1 by x:
+	0000 0001 << x
+
+	so if x = 2, 2^2 = 4 -> 100
+
+	0000 0001 << 2  ---> 0000 0100
+
+
+6. Is power of 2?
+	just do x&(x-1).
+	if 0 --> yes!

MY_BOOK/ebook_src/bitwise_operations/clear_bits.py

@@ -0,0 +1,37 @@
+#!/usr/bin/env python
+
+__author__ = "bt3"
+
+''' Clear a bit in a binary number.
+    Like the reverse of set bit:
+    1) first create a number filled of 1s,
+        with 0 at i (can create 0001000 and ~)
+    2) AND the number so it clears the ith bit
+'''
+
+
+
+def clear_bit(num, i):
+    mask = ~ (1 << i)   # -0b10001
+    return bin(num & mask)
+
+
+def clear_all_bits_from_i_to_0(num, i):
+    mask = ~ ( (1 << (i+1)) - 1)
+    return bin(num & mask)
+
+
+def clear_all_bits_from_most_sig_to_1(num, i):
+    mask =  ( 1 << i) -1
+    return bin(num & mask)
+
+
+if __name__ == '__main__':
+    num = int('10010000', 2)
+    print clear_bit(num, 4)   # '0b10000000'
+
+    num = int('10010011', 2)
+    print clear_all_bits_from_i_to_0(num, 2)  # '0b10010000'
+
+    num = int('1110011', 2)
+    print clear_all_bits_from_most_sig_to_1(num, 2)  #'0b11'

MY_BOOK/ebook_src/bitwise_operations/find_bit_len.py

@@ -1,28 +1,25 @@
-#!/usr/bin/python3
-# mari von steinkirch @2013
-# steinkirch at gmail
+#!/usr/bin/env python
+
+__author__ = "bt3"
 
 ''' Find how many bits a int has:
     1) Start with a mask of 1
     2) Mask with AND
     3) if result (if true): count += 1
-    (obs: to find the int of a bin do int('1001', 2)) and to show in bin do bin(int))
-    
-    >>> for i in range(17): print(find_bit_len(i))
+    (obs: to find the int of a bin do int('1001', 2)) and to show in bin
+    do bin(int))
 '''
 
 
-
 def find_bit_len(int_num):
     lenght = 0
     while int_num:
         int_num >>= 1
         lenght += 1
     return lenght
-    
-    
+
 
 if __name__ == '__main__':
-    import doctest
-    doctest.testmod()
-
+    for i in range(17):
+        print(find_bit_len(i))
+        print i.bit_length()

MY_BOOK/ebook_src/bitwise_operations/find_how_many_1_binary.py

@@ -1,21 +1,22 @@
-#!/usr/bin/python3
-# mari von steinkirch @2013
-# steinkirch at gmail
+#!/usr/bin/env python
+
+__author__ = "bt3"
 
 ''' Find how many 1s in the binary:
     1) Start with a mask of 1
     2) Mask with AND
     3) if result (if true): count += 1
-    (obs: to find the int of a bin do int('1001', 2)) and to show in bin do bin(int))
-    
-    >>> find_how_many_1_in_a_binary(9)
-    2
-
+    (obs: to find the int of a bin do int('1001',
+        2)) and to show in bin do bin(int))
 '''
 
 
-
 def find_how_many_1_in_a_binary(n):
+    '''
+    >>> find_how_many_1_in_a_binary(9)
+    2
+    '''
+
     counter = 0
     while n:
         if n & 1:
@@ -24,9 +25,6 @@ def find_how_many_1_in_a_binary(n):
     return counter
 
 
-    
-    
-    
 
 if __name__ == '__main__':
     import doctest

MY_BOOK/ebook_src/bitwise_operations/get_bit.py

@@ -0,0 +1,27 @@
+#!/usr/bin/env python
+
+__author__ = "bt3"
+
+''' Get a bit in a binary number:
+    1) Shifts 1 over by i bits
+    2) make an AND with the number
+    3) all the other than the bit at i are clean, now compare to 0
+    4) if the new value is not 0, bit i is 1
+'''
+
+
+def get_bit(num, i):
+    mask = 1 << i
+    return num & mask != 0
+
+
+if __name__ == '__main__':
+    num = int('0100100', 2)
+    get_bit(num, 0)   # 0
+    get_bit(num, 1)   # 0
+    get_bit(num, 2)   # 1
+    get_bit(num, 3)   # 0
+    get_bit(num, 4)   # 0
+    get_bit(num, 5)   # 1
+    get_bit(num, 6)   # 0
+

MY_BOOK/ebook_src/bitwise_operations/get_float_rep_bin.py

@@ -1,20 +1,22 @@
-#!/usr/bin/python3
-# mari von steinkirch @2013
-# steinkirch at gmail
+#!/usr/bin/env python
+
+__author__ = "bt3"
 
 ''' Given a real number between 0 and 1 (eg: 0.72), this method print the binary
     representation. If the Number cannot be represented accurately in binary, with at
     most 32 chars, print error:
-    
+'''
+
+def get_float_rep(num):
+    '''
     >>> get_float_rep(0.72)
     ('Error 2', '.1011100001010001111010111000010')
     >>> get_float_rep(0.1)
     ('Error 2', '.0001100110011001100110011001100')
     >>> get_float_rep(0.5)
     '.1'
-'''
+    '''
 
-def get_float_rep(num):
     if num >= 1 or num <= 0: return 'Error 1'
     result = '.'
     while num:
@@ -27,7 +29,7 @@ def get_float_rep(num):
             result += '0'
             num = r
     return result
-    
+
 
 if __name__ == '__main__':
     import doctest

MY_BOOK/ebook_src/bitwise_operations/insert_small_bin_into_big_bin.py

@@ -1,33 +1,34 @@
-#!/usr/bin/python3
-# mari von steinkirch @2013
-# steinkirch at gmail
+#!/usr/bin/env python
+
+__author__ = "bt3"
+
 
 ''' Given two 32-bit numbers, N and M, and two bit positions, i and j, this
-    method insert M into N such that M starts at bit j and ends at bit i: 
+    method insert M into N such that M starts at bit j and ends at bit i:
     1) clear the bits j thru i in N'
     2) shift M so that it lines up with bits j thru i
     3) merge M and N
+'''
 
+def insert_small_bin_into_big_bin(M, N, i, j):
+    '''
     >>> N = 0b10000000000
     >>> M = 0b10011
     >>> j = 6
     >>> i = 2
     >>> insert_small_bin_into_big_bin(M, N, i, j)
     '0b10001001100'
-'''
+    '''
 
-def insert_small_bin_into_big_bin(M, N, i, j):
     allOnes = ~0
     left = allOnes << (j+1) # 1110000
     right = ( (1 << i) - 1) # 0000111
     mask = left | right     # 1110111
     N_cleared = N & mask
     M_shifted = M << i
-    
+
     return bin( N_cleared | M_shifted)
-    
-  
-    
+
 
 if __name__ == '__main__':
     import doctest

MY_BOOK/ebook_src/bitwise_operations/next_with_same_num_1s.py

@@ -1,27 +1,19 @@
-#!/usr/bin/python3
-# mari von steinkirch @2013
-# steinkirch at gmail
+#!/usr/bin/env python
+
+__author__ = "bt3"
+
 
 ''' Give a positive int, print the next smallest and next largest ints with
     same number of 1 bits.
     The brute force is:
     1) find number of 1 bits
     2) loop above and down until find same, checking for each
-    
-    >>> num = 0b1001
-    >>> next = '0b1010'
-    >>> prev = '0b110'
-    >>> print_prev_same_1s(num) == prev
-    True
-    >>> print_next_same_1s(num) == next
-    True
-
 '''
 
 
 
 def print_prev_same_1s(num):
-    n1s = find_num_1s(num)   
+    n1s = find_num_1s(num)
     # find prev
     i = num-1
     while True:
@@ -31,10 +23,10 @@ def print_prev_same_1s(num):
         i -= 1
         if i < 0:
             return None
- 
+
 def print_next_same_1s(num):
-    n1s = find_num_1s(num)        
-    # find next   
+    n1s = find_num_1s(num)
+    # find next
     i = num+1
     while True:
         n1s_here = find_num_1s(i)
@@ -43,8 +35,8 @@ def print_next_same_1s(num):
         i += 1
         if i < 0:
             return None
-    
-    
+
+
 
 def find_num_1s(num):
     counter = 0
@@ -54,11 +46,14 @@ def find_num_1s(num):
         num >>= 1
     return counter
 
-    
-    
-    
+
+
+
 
 if __name__ == '__main__':
-    import doctest
-    doctest.testmod()
+    num = 0b1001
+    n = '0b1010'
+    p = '0b110'
+    print_prev_same_1s(num) == p
+    print_next_same_1s(num) == n
 

MY_BOOK/ebook_src/bitwise_operations/num_bits_to_convert_2_nums.py

@@ -1,18 +1,12 @@
-#!/usr/bin/python3
-# mari von steinkirch @2013
-# steinkirch at gmail
+#!/usr/bin/env python
+
+__author__ = "bt3"
+
 
 ''' This method returns the number of bits that are necessary to change to convert two
     numbers A and B:
     1) XOR
     2) count 1s
-        
-    >>> a = int('10010000', 2)
-    >>> b = int('01011010', 2)
-    >>> count_bits_swap(a, b)  
-    4
-    >>> count_bits_swap2(a, b)  
-    4
 '''
 
 def count_bits_swap2(a, b):
@@ -28,8 +22,8 @@ def count_bits_swap2(a, b):
 def count_bits_swap(a, b):
     m = a^b
     return count_1s(m)
-    
-    
+
+
 def count_1s(m):
     count = 0
     while m:
@@ -37,9 +31,10 @@ def count_1s(m):
             count +=1
         m >>= 1
     return count
-    
+
 
 if __name__ == '__main__':
-    import doctest
-    doctest.testmod()
-
+    a = int('10010000', 2)
+    b = int('01011010', 2)
+    print count_bits_swap(a, b)  #4
+    print count_bits_swap2(a, b)  #4

MY_BOOK/ebook_src/bitwise_operations/set_bit.py

@@ -0,0 +1,26 @@
+#!/usr/bin/env python
+
+__author__ = "bt3"
+
+
+
+''' Set a bit in a binary number:
+    1) Shifts 1 over by i bits
+    2) make an OR with the number, only the value at bit i will change and all the others bit
+    of the mask are zero so will not affect the num
+'''
+
+
+def set_bit(num, i):
+    mask = 1 << i
+    return bin( num | mask )
+
+
+if __name__ == '__main__':
+    num = int('0100100', 2)
+    print set_bit(num, 0)   #'0b100101'
+    print set_bit(num, 1)   #'0b100110'
+    print set_bit(num, 2)   # nothing change '0b100100'
+    print set_bit(num, 3)   #'0b101100'
+    print set_bit(num, 4) #'0b110100'
+    print set_bit(num, 5)     # nothing change '0b100100'

MY_BOOK/ebook_src/bitwise_operations/swap_in_place.py

@@ -0,0 +1,23 @@
+#!/usr/bin/env python
+
+__author__ = "bt3"
+
+'''
+    swapping values in place without extra memory
+'''
+
+
+def swap_bit(a, b):
+    '''
+    >>> swap_bit(14, 73)
+    (73, 14)
+    '''
+    a = a^b
+    b = a^b
+    a = a^b
+    return a, b
+
+
+if __name__ == '__main__':
+    import doctest
+    doctest.testmod()

MY_BOOK/ebook_src/bitwise_operations/swap_odd_even.py

@@ -1,6 +1,7 @@
-#!/usr/bin/python3
-# mari von steinkirch @2013
-# steinkirch at gmail
+#!/usr/bin/env python
+
+__author__ = "bt3"
+
 
 ''' Swap odd and even bits in a smart way in a binary:
     1) first for odds, take n and move the odd:
@@ -8,17 +9,18 @@
         (b) shift by right by 1
     2) do the same to ints with 01010101
     3) merge
-    
-    >>> num = 0b11011101
-    >>> result = '0b1101110'
-    >>> swap_odd_even(num) == result
-    True
-
 '''
 
 
 
 def swap_odd_even(num):
+    '''
+    >>> num = 0b11011101
+    >>> result = '0b1101110'
+    >>> swap_odd_even(num) == result
+    True
+    '''
+
     mask_odd = 0xAA # 0b10101010
     mask_even = 0x55 # 0b1010101
     odd = num & mask_odd
@@ -28,9 +30,6 @@ def swap_odd_even(num):
     return bin(odd | even)
 
 
-    
-    
-    
 
 if __name__ == '__main__':
     import doctest

MY_BOOK/ebook_src/bitwise_operations/update_bit.py

@@ -1,26 +1,22 @@
-#!/usr/bin/python3
-# mari von steinkirch @2013
-# steinkirch at gmail
+#!/usr/bin/env python
+
+__author__ = "bt3"
 
 ''' This method merges set bit and clean bit:
     1) first clear the bit at i using a mask such as 1110111
     2) then shift the intended value v by i bits
     3) this will create a number with bit i to v and all other to 0
     4) finally update the ith bit with or
-        
-    >>> num = int('10010000', 2)
-    >>> update_bit(num, 2, 1)   
-    '0b10010100'
 '''
 
 
 
 def  update_bit(num, i, v):
     mask = ~ (1 << i)
-    return bin( (num & mask) | (v << i) )    
-    
+    return bin( (num & mask) | (v << i) )
+
 
 if __name__ == '__main__':
-    import doctest
-    doctest.testmod()
+    num = int('10010000', 2)
+    print update_bit(num, 2, 1)   # '0b10010100'
 

MY_BOOK/ebook_src/builtin_structures/anagram.py

@@ -0,0 +1,51 @@
+#!/usr/bin/env python
+
+__author__ = "bt3"
+
+
+from collections import Counter
+
+def is_anagram(s1, s2):
+    '''
+    >>> is_anagram('cat', 'tac')
+    True
+    >>> is_anagram('cat', 'hat')
+    False
+    '''
+    counter = Counter()
+    for c in s1:
+        counter[c] += 1
+
+    for c in s2:
+        counter[c] -= 1
+
+    for i in counter.values():
+        if i:
+            return False
+
+    return True
+
+''' verify if words are anagrams by comparing a sum of  Unicode code
+point of the character'''
+
+def get_unicode_sum(word):
+    s = 0
+    for p in word:
+        s += ord(p)
+    return s
+
+
+def is_anagram2(word1, word2):
+    '''
+    >>> is_anagram2('cat', 'tac')
+    True
+    >>> is_anagram2('cat', 'hat')
+    False
+    '''
+    return get_unicode_sum(word1) == get_unicode_sum(word2)
+
+
+if __name__ == '__main__':
+    import doctest
+    doctest.testmod()
+

MY_BOOK/ebook_src/builtin_structures/balance.txt

@@ -0,0 +1,9 @@
+__author__ = "bt3"
+
+
+This is the classic "you have 8 balls/coins, which are the same weight, except for one which is slightly heavier than the others. You also have an old-style balance. What is the fewest number of weighings to find the heavy coin/ball?
+
+Answer: 2! You need to use every information available:
+Weight 3 x 3 balls/coins.
+If they weight the same: weight the 2 balls/coins left outside.
+Else, measure 2 of the 3 heavier balls/coins.

MY_BOOK/ebook_src/builtin_structures/balance_symbols.py

@@ -0,0 +1,40 @@
+#!/usr/bin/env python
+
+__author__ = "bt3"
+
+'''
+Given a N different open and close braces in a string "( { [ } ] )".
+How do you check whether the string has matching braces.
+'''
+
+from collections import Counter
+def check_if_balance(string):
+    '''
+    >>> check_if_balance('{[[(])}]')
+    True
+    >>> check_if_balance('{[[()}]')
+    False
+    >>> check_if_balance('')
+    True
+    '''
+    table = Counter()
+    for i in string:
+
+        index = str(ord(i))[0]
+        if i in '{[(':
+            table[index] += 1
+
+        elif i in ')}]':
+            table[index] -= 1
+
+    for i in table.values():
+        if i !=-0:
+            return False
+    return True
+
+
+
+if __name__ == '__main__':
+    import doctest
+    doctest.testmod()
+

MY_BOOK/ebook_src/builtin_structures/check_if_2_numbers_sum_to_k.py

@@ -0,0 +1,71 @@
+#!/usr/bin/env python
+
+__author__ = "bt3"
+
+"""
+Given an integer x and an unsorted array of integers, describe an
+algorithm to determine whether two of the numbers add up to x.
+
+1. Using hash tables.
+2. Sorting the array and keeping two pointers in the array, one in
+the beginning and one in the end. Whenever the sum of the current
+two integers is less than x, move the first pointer forwards, and
+whenever the sum is greater than x, move the second pointer
+backwards. O(nln n).
+3. Create a BST with x minus each element in the array.
+Check whether any element of the array appears in the BST.
+It takes O(nlog n) times two.
+"""
+
+from collections import defaultdict, Counter
+
+def check_sum(array, k):
+    '''
+    >>> check_sum([3, 2, 6, 7, 9, 1], 8)
+    [(6, 2), (1, 7)]
+    >>> check_sum([5, 2, 6, 7, 9, 1], 4)
+    []
+    >>>
+    '''
+
+    dict = defaultdict()
+    res = []
+
+    for i in array:
+        if k-i in dict:
+            res.append((i, k-i))
+            del dict[k-i]
+        else:
+            dict[i] = 1
+
+    return res
+
+
+def check_sum2(array, k):
+    '''
+    >>> check_sum2([1, 4, 2, 7, 1, 3, 10, 15, 3, 1], 6)
+    set([(3, 3)])
+    >>> check_sum2([1, 4, 2, 7, 1, 3, 10, 15, 3, 1], 0)
+    set([])
+    '''
+
+    dict = Counter()
+    res = set()
+
+    for i in array:
+        dict[i] += 1
+
+    for i in array:
+        if dict[k-i] > 0:
+            if i == k-i and dict[k-i] > 1:
+                    res.add((i, k-i))
+                    dict[k-i] -= 2
+            elif i == k-i:
+                res.add((i, k-i))
+                dict[k-i] -= 1
+
+    return res
+
+if __name__ == '__main__':
+    import doctest
+    doctest.testmod()

MY_BOOK/ebook_src/builtin_structures/check_if_3_numbers_sum_to_zero.py

@@ -0,0 +1,36 @@
+#!/usr/bin/env python
+
+__author__ = "bt3"
+
+
+''' Determine if an Array of integers contains 3 numbers that sum to 0 '''
+
+from collections import defaultdict
+
+def find_3_number(array):
+    '''
+    >>> find_3_number([1,5,56,11,-3,-12])
+    1 11 -12
+    True
+    >>> find_3_number([] )
+    False
+    '''
+    hash_ = defaultdict()
+    for i in array:
+        hash_[i] = 1
+
+    for i, x in enumerate(array):
+        for y in array[i+1:]:
+            if -(x+y) in hash_:
+                print x, y, -(x+y)
+                return True
+
+    return False
+
+
+
+
+if __name__ == '__main__':
+    import doctest
+    doctest.testmod()
+

MY_BOOK/ebook_src/builtin_structures/check_non_overlapping_intervals.py

@@ -0,0 +1,35 @@
+#!/usr/bin/env python
+
+__author__ = "bt3"
+
+
+'''
+given an array of intervals, return max number of non-overlapping intervals
+'''
+
+from collections import defaultdict
+
+def non_overlapping(array):
+    '''
+    >>> non_overlapping([(1,2), (2,5), (1, 6)])
+    [[(1, 2), (2, 5)]]
+    >>> non_overlapping([(1,4), (2,5), (3, 6)])
+    []
+    '''
+    total = []
+
+    for i, t in enumerate(array):
+        start = t[0]
+        end = t[1]
+        for tt in array[i+1:] :
+            if end <= tt[0]:
+                total.append([(start, end), (tt[0], tt[1])])
+
+    return total
+
+
+
+if __name__ == '__main__':
+    import doctest
+    doctest.testmod()
+

MY_BOOK/ebook_src/builtin_structures/convert_numerical_bases.py

@@ -0,0 +1,64 @@
+#!/usr/bin/env python
+
+__author__ = "bt3"
+
+''' convert an integer to a string in any base'''
+
+def convert_from_dec_to_any_base(number, base):
+    '''
+    >>> number, base = 9, 2
+    >>> convert_from_dec_to_any_base(number, base)
+    '1001'
+    '''
+
+    convertString = '012345679ABCDEF'
+
+    if number < base:
+        return convertString[number]
+
+    else:
+        return convert_from_dec_to_any_base(number//base, base) + \
+                                            convertString[number%base]
+
+
+
+def convert_from_decimal_to_binary(number, base):
+    '''
+    >>> number, base = 9, 2
+    >>> convert_from_decimal_to_binary(number, base)
+    1001
+    '''
+
+    multiplier, result = 1, 0
+
+    while number > 0:
+        result += number%base*multiplier
+        multiplier *= 10
+        number = number//base
+
+    return result
+
+
+
+def convert_from_decimal_larger_bases(number, base):
+    '''
+    >>> number, base = 31, 16
+    >>> convert_from_decimal_larger_bases(number, base)
+    '1F'
+    '''
+    strings = "0123456789ABCDEFGHIJ"
+    result = ""
+
+    while number > 0:
+        digit = number%base
+        result = strings[digit] + result
+        number = number//base
+
+    return result
+
+
+
+if __name__ == '__main__':
+    import doctest
+    doctest.testmod()
+

MY_BOOK/ebook_src/builtin_structures/convert_str_2_int.py

@@ -1,9 +1,10 @@
-#!/usr/bin/python3
-# mari von steinkirch @2013
-# steinkirch at gmail
+#!/usr/bin/env python
 
-''' two routines to convert str to int and int to str:
-    - bc: negative str, zero, exp numbers (ex. 1e5), other bases, NAN 
+__author__ = "bt3"
+
+
+def conv_int2str(int1):
+    '''
     >>> conv_str2int('367')
     367
     >>> conv_str2int('0')
@@ -12,46 +13,59 @@
     -10
     >>> conv_str2int('1e5')
     100000
-    >>> conv_int2str(0)
-    '0'
-    >>> conv_int2str(1e5)
-    '100000' 
-    >>> conv_int2str(367)
-    '367'
-    >>> conv_int2str(-10)
-    '-10'
-'''
+    '''
 
-def conv_int2str(int1):
     aux_dict = {key:value for key in range(10) for value in '0123456789'[key]}
-    if int1 == 0: return '0'    # REMEMBER TO HANDLE 0
-    if int1 < 0:                # REMEMBER TO HANDLE NEGATIVE
+
+    if int1 == 0:
+        return '0'
+    elif int1 < 0:
         sign = '-'
         int1 = int1*(-1)
     else:
         sign = ''
+
+
     aux_ls = []
+
     while int1 > 0:
         c = int1%10
         int1 = int1//10
         cadd = aux_dict[c]
         aux_ls.append(cadd)
-    aux_ls.reverse()            # REMEMBER TO REVERSE
+
+    aux_ls.reverse()
+
     return sign + ''.join(aux_ls)
-    
+
 
 
 def conv_str2int(str1):
-    if not str1: return None
+    '''
+    >>> conv_int2str(0)
+    '0'
+    >>> conv_int2str(1e5)
+    '100000'
+    >>> conv_int2str(367)
+    '367'
+    >>> conv_int2str(-10)
+    '-10'
+    '''
+    if not str1:
+        return None
+
     aux_dict = {key:value for value in range(10) for key in '0123456789'[value]}
-    if str1[0] == '-': 
+
+    if str1[0] == '-':
         sign = -1
-        str1 = str1[1:]                 # REMEMBER TO CUT THE SIGN FROM THE STR
-    else: 
+        str1 = str1[1:]
+    else:
         sign = 1
+
     dec, result = 1, 0
-    for i in range(len(str1)-1, -1, -1): # REMEMBER TO FINISH IN -1, NOT 0, AND
-        aux = str1[i]                    # AND DO THE STEPS -1
+
+    for i in range(len(str1)-1, -1, -1):
+        aux = str1[i]
         if aux == 'e':
             exp_num = conv_str2int(str1[i+1:])
             number = conv_str2int(str1[:i])
@@ -59,8 +73,9 @@ def conv_str2int(str1):
             break
         result += aux_dict[aux]*dec
         dec *= 10
+
     return result*sign
-    
+
 
 if __name__ == '__main__':
     import doctest

MY_BOOK/ebook_src/builtin_structures/count_unique_words_On2.py

@@ -1,21 +1,26 @@
-#!/usr/bin/python3
-# mari von steinkirch @2013
-# steinkirch at gmail
+#!/usr/bin/env python
+
+__author__ = "bt3"
 
 import collections
 import string
 import sys
 
+
 def count_unique_word():
+
     words = collections.defaultdict(int)
-    strip = string.whitespace + string.punctuation + string.digits + "\"'" 
+
+    strip = string.whitespace + string.punctuation + string.digits + "\"'"
+
     for filename in sys.argv[1:]:
         with open(filename) as file:
-            for line in file:	
+            for line in file:
                 for word in line.lower().split():
                     word = word.strip(strip)
                     if len(word) > 2:
                         words[word] = +1
+
     for word in sorted(words):
         print("'{0}' occurs {1} times.".format(word, words[word]))
-        
+

MY_BOOK/ebook_src/builtin_structures/delete_duplicate_char_str.py

@@ -0,0 +1,49 @@
+#!/usr/bin/env python
+
+__author__ = "bt3"
+
+'''  find and delete all the duplicate characters in a string '''
+
+from collections import Counter
+
+def delete_unique(str1):
+    '''
+    >>> delete_unique("Trust no one")
+    'on'
+    >>> delete_unique("Mulder?")
+    ''
+    '''
+
+    str_strip = ''.join(str1.split())
+    repeat = Counter()
+
+    for c in str_strip:
+        repeat[c] += 1
+
+    result = ''
+    for c, count in repeat.items():
+        if count > 1:
+            result += c
+
+    return result
+
+
+def removing_duplicates_seq(str1):
+    '''
+    >>> delete_unique("Trust no one")
+    'on'
+    >>> delete_unique("Mulder?")
+    ''
+    '''
+    seq = str1.split()
+    result = set()
+    for item in seq:
+        if item not in result:
+            #yield item
+            result.add(item)
+    return result
+
+
+if __name__ == '__main__':
+    import doctest
+    doctest.testmod()

MY_BOOK/ebook_src/builtin_structures/fibonacci.py

@@ -0,0 +1,60 @@
+#!/usr/bin/env python
+
+__author__ = "bt3"
+
+
+def fib_generator():
+    a, b = 0, 1
+
+    while True:
+        yield b
+        a, b = b, a+b
+
+
+def fib(n):
+    '''
+    >>> fib(2)
+    1
+    >>> fib(5)
+    5
+    >>> fib(7)
+    13
+    '''
+    if n < 3:
+        return 1
+
+    a, b = 0, 1
+    count = 1
+
+    while count < n:
+        count += 1
+        a, b = b, a+b
+
+    return b
+
+
+def fib_rec(n):
+    '''
+    >>> fib_rec(2)
+    1
+    >>> fib_rec(5)
+    5
+    >>> fib_rec(7)
+    13
+    '''
+    if n < 3:
+        return 1
+    return fib_rec(n - 1) + fib_rec(n - 2)
+
+
+
+
+if __name__ == '__main__':
+    import doctest
+    doctest.testmod()
+
+    fib = fib_generator()
+    print(next(fib))
+    print(next(fib))
+    print(next(fib))
+    print(next(fib))

MY_BOOK/ebook_src/builtin_structures/find_0_MxN_replace_cols_rows.py

@@ -1,8 +1,8 @@
-#!/usr/bin/python3
-# mari von steinkirch @2013
-# steinkirch at gmail
+#!/usr/bin/env python
+
+__author__ = "bt3"
+
 
-   
 def find_0_MxN(m):
     ''' find 0s in a matrix and replace the col and row to 0s:
     >>> m1 = [[1,2,3,4], [5,6,7,8], [9,10,11,12], [13,14,15,16]]
@@ -13,6 +13,7 @@ def find_0_MxN(m):
     [[0, 2, 3, 4], [0, 0, 0, 0], [0, 10, 11, 12], [0, 14, 15, 16]]
     '''
     index = []
+
     for row in range(len(m)):
         for col in range(len(m[0])):
             if m[row][col] == 0:
@@ -24,9 +25,10 @@ def find_0_MxN(m):
             m[row][i] = 0
         for i in range(len(m[0])):
             m[i][col] = 0
+
     return m
 
-                   
+
 if __name__ == '__main__':
     import doctest
     doctest.testmod()

MY_BOOK/ebook_src/builtin_structures/find_dice_probabilities.py

@@ -0,0 +1,32 @@
+#!/usr/bin/env python
+
+__author__ = "bt3"
+
+'''
+given 2 dice, determine number of ways to sum S if all dice are rolled
+'''
+
+from collections import Counter, defaultdict
+
+def find_dice_probabilities(S=5, n_faces=6):
+    if S > 2*n_faces or S < 2:
+        return None
+
+    cdict = Counter()
+    ddict = defaultdict(list)
+
+    for dice1 in range(1, n_faces+1):
+        for dice2 in range(1, n_faces+1):
+            t = [dice1, dice2]
+            cdict[dice1+dice2] += 1
+            ddict[dice1+dice2].append( t)
+
+    return [cdict[S], ddict[S]]
+
+
+
+
+
+if __name__ == '__main__':
+    results = find_dice_probabilities()
+    assert(results[0] == len(results[1]))

MY_BOOK/ebook_src/builtin_structures/find_edit_distance.py

@@ -0,0 +1,43 @@
+#!/usr/bin/env python
+
+__author__ = "bt3"
+
+
+''' computes the edit distance between two strings '''
+
+
+def find_edit_distance(str1, str2):
+    '''
+    >>> s = 'sunday'
+    >>> t = 'saturday'
+    >>> find_edit_distance(s, t)
+    3
+    '''
+
+	m = len(str1)
+	n = len(str2)
+	diff = lambda c1, c2: 0 if c1 == c2 else 1
+
+	E = [[0] * (n + 1) for i in range(m + 1)]
+
+	for i in range(m + 1):
+		E[i][0] = i
+
+    for j in range(1, n + 1):
+		E[0][j] = j
+
+    for i in range(1, m + 1):
+		for j in range(1, n + 1):
+			E[i][j] = min(E[i-1][j] + 1, E[i][j-1] + 1, E[i-1][j-1] + diff(str1[i-1], str2[j-1]))
+
+    return E[m][n]
+
+
+
+if __name__ == '__main__':
+    import doctest
+    doctest.testmod()
+
+
+
+

MY_BOOK/ebook_src/builtin_structures/find_first_non_repetead_char.py

@@ -0,0 +1,29 @@
+#!/usr/bin/env python
+
+__author__ = "bt3"
+
+from collections import Counter
+
+def  find_non_rep_char(s1):
+  '''
+  >>> s1 = 'aabbcceff'
+  >>> find_non_rep_char(s1)
+  e
+  >>> find_non_rep_char('ccc')
+  '''
+
+  aux_dict = Counter()
+
+  for i in s1:
+      aux_dict[i] += 1
+
+  for k, v in aux_dict.items():
+    if v < 2:
+        print k
+
+
+
+if __name__ == '__main__':
+    import doctest
+    doctest.testmod()
+

MY_BOOK/ebook_src/builtin_structures/find_gcd.py

@@ -1,13 +1,14 @@
-#!/usr/bin/python3
-# mari von steinkirch @2013
-# steinkirch at gmail
+#!/usr/bin/env python
+
+__author__ = "bt3"
+
 
 
 def finding_gcd(a, b):
     ''' implements the greatest common divider algorithm '''
     while(b != 0):
         result = b
-        a, b = b, a % b        
+        a, b = b, a % b
     return result
 
 
@@ -22,7 +23,7 @@ if __name__ == '__main__':
 
 
 
-    
-    
-    
-    
+
+
+
+

MY_BOOK/ebook_src/builtin_structures/find_if_substr.py

@@ -0,0 +1,36 @@
+#!/usr/bin/env python
+
+__author__ = "bt3"
+
+
+def find_substr(s1, s2):
+
+    if len(s1) < len(s2):
+        bs = s2
+        ss = s1
+    else:
+        bs = s1
+        ss = s2
+
+    ps = 0
+
+    for c in bs:
+
+        if ss[ps] == c:
+            ps += 1
+        else:
+            ps = 0
+
+        if ps == len(ss)-1:
+            return True
+
+    return False
+
+
+
+if __name__ == '__main__':
+    s1 = 'buffy is a vampire slayer'
+    s2 = 'vampire'
+    s3 = 'angel'
+    assert(find_substr(s2, s1) == True)
+    assert(find_substr(s3, s1) == False)

MY_BOOK/ebook_src/builtin_structures/find_if_unique_char.py

@@ -0,0 +1,32 @@
+#!/usr/bin/env python
+
+__author__ = "bt3"
+
+
+
+import collections
+
+def find_if_unique_chars(word):
+    """
+    >>> find_if_unique_chars('abcde')
+    True
+    >>> find_if_unique_chars('abcae')
+    False
+    """
+
+    unique = True
+
+    counter = collections.Counter()
+
+    for c in word:
+        if not counter[c]:
+            counter[c] += 1
+        else:
+            unique = False
+
+    return unique
+
+
+if __name__ == '__main__':
+    import doctest
+    doctest.testmod()

MY_BOOK/ebook_src/builtin_structures/find_largest_sum.py

@@ -0,0 +1,42 @@
+#!/usr/bin/env python
+
+__author__ = "bt3"
+
+
+
+'''
+   You are given an array of integers (both positive and negative).
+   Find the contiguous sequence with the largest sum.
+'''
+
+
+def find_largest_sum(array):
+    '''
+    >>> find_largest_sum([-1, 2, -3, 5, 3, 1, -16, 7, 1, -13, 1])
+    9
+    >>> find_largest_sum([])
+    0
+    >>> find_largest_sum([1])
+    1
+    '''
+
+    sum_ = 0
+    sum_here = 0
+
+    for i in array:
+
+        sum_here +=  i
+
+        if sum_here < 0:
+            sum_here = 0
+
+        if sum_ < sum_here:
+            sum_ = sum_here
+
+    return sum_
+
+
+
+if __name__ == '__main__':
+    import doctest
+    doctest.testmod()

MY_BOOK/ebook_src/builtin_structures/find_longest_inc_subseq.py

@@ -0,0 +1,34 @@
+#!/usr/bin/env python
+
+__author__ = "bt3"
+
+''' find the longest continuous increasing subsequence'''
+
+
+def find_long_con_inc(seq):
+    '''
+    >>> find_long_con_inc([1, -2, 3, 5, 1, -1, 4, -1, 6])
+    [-2, 3, 5]
+    >>> find_long_con_inc([1, 3, -2, 3, 5, 6])
+    [-2, 3, 5, 6]
+    >>> find_long_con_inc([1, 3, 4, -13, 2, 5, 8, -1, 2,-17])
+    [-13, 2, 5, 8]
+    '''
+
+    res, aux = [], []
+    seq.append(-float('infinity'))
+
+    for i, n in enumerate(seq[:-1]):
+        aux.append(n)
+        if n > seq[i+1]:
+            if len(res) < len(aux):
+                res = aux[:]
+            aux = []
+
+    return res
+
+
+
+if __name__ == '__main__':
+    import doctest
+    doctest.testmod()

MY_BOOK/ebook_src/builtin_structures/find_longest_str_unique_chars.py

@@ -0,0 +1,38 @@
+#!/usr/bin/env python
+
+__author__ = "bt3"
+
+
+'''
+given a string, find longest string with unique characters
+'''
+
+def find_longest(string):
+    '''
+    >>> find_longest('abfgrhgtrdsandwejfhdasjcbdsjvrejwghireeej')
+    'wejfhdas'
+    >>> find_longest('abcabcabcabcdefabcccc')
+    'defabc'
+    '''
+    maxs = ''
+    result = ''
+
+    for c in string:
+        if c in result:
+            if len(maxs) < len(result):
+                maxs = result
+            result = ''
+        else:
+            result += c
+
+    if result and len(maxs) < len(result):
+        maxs = result
+
+    return maxs
+
+
+
+if __name__ == '__main__':
+    import doctest
+    doctest.testmod()
+

MY_BOOK/ebook_src/builtin_structures/find_non_repeating_number.py

@@ -0,0 +1,33 @@
+#!/usr/bin/env python
+
+__author__ = "bt3"
+
+
+from collections import defaultdict
+
+
+def find_unique_number(array):
+    '''
+    >>> find_unique_number([1, 3, 6, 1, 5, 6, 9, 3, 7])
+    [1, 6, 3]
+    >>> find_unique_number([1, 3, 5, 6, 9, 7])
+    []
+    '''
+
+    table = defaultdict()
+    total = []
+
+    for i in array:
+        if i in table:
+            total.append(i)
+        else:
+            table[i] = 1
+
+    return total
+
+
+
+
+if __name__ == '__main__':
+    import doctest
+    doctest.testmod()

MY_BOOK/ebook_src/builtin_structures/find_product_without_division.py

@@ -0,0 +1,42 @@
+#!/usr/bin/env python
+
+__author__ = "bt3"
+
+'''Given an array of numbers, replace each number with the product of all
+the numbers in the array except the number itself *without* using division
+'''
+
+
+def find_product_without_division(seq):
+    '''
+    >>> seq = [2,3,4]
+    >>> find_product_without_division(seq)
+    [12, 8, 6]
+    '''
+
+    forw = []
+    bacw = []
+
+    for i in range(len(seq)):
+
+        prod_f, prod_b = 1, 1
+
+        for next in range(i+1, len(seq)):
+            prod_f *= seq[next]
+
+        for before in range(0, i):
+            prod_b *= seq[before]
+
+        forw.append(prod_f)
+        bacw.append(prod_b)
+
+    for i in range(len(seq)):
+        seq[i] = forw[i] * bacw[i]
+
+    return seq
+
+
+
+if __name__ == '__main__':
+    import doctest
+    doctest.testmod()

MY_BOOK/ebook_src/builtin_structures/find_top_N_recurring_words.py

@@ -1,6 +1,6 @@
-#!/usr/bin/python3
-# mari von steinkirch @2013
-# steinkirch at gmail
+#!/usr/bin/env python
+
+__author__ = "bt3"
 
 from collections import Counter
 
@@ -8,24 +8,20 @@ def find_top_N_recurring_words(seq, N):
     ''' find the top N recurring words in a file:
         1) use a hash table to find counts
         2) sort the list on base of the maximum counts
-        3) return the last N words '''
+        3) return the last N words
+    '''
 
     dcounter = Counter()
     for word in seq.split():
-        dcounter[word] += 1    
+        dcounter[word] += 1
+
     return dcounter.most_common(N)
-    
 
 
-def test_find_top_N_recurring_words(module_name='this module'):
-    seq = 'buffy angel monster xander a willow gg buffy the monster super buffy angel'
-    N = 3
-    assert(find_top_N_recurring_words(seq, N) == [('buffy', 3), ('monster', 2), ('angel', 2)])
-       
-    s = 'Tests in {name} have {con}!'
-    print(s.format(name=module_name, con='passed'))
-
 
 if __name__ == '__main__':
-    test_find_top_N_recurring_words()
+    seq = 'buffy angel monster xander a willow gg buffy the monster super buffy angel'
+    N = 3
+    assert(find_top_N_recurring_words(seq, N) == [('buffy', 3), ('monster', 2), ('angel', 2)])
+
 

MY_BOOK/ebook_src/builtin_structures/find_two_missing_numbers_in_sequence.py

@@ -0,0 +1,56 @@
+#!/usr/bin/env python
+
+__author__ = "bt3"
+
+"""
+Two numbers out of n numbers from 1 to n are missing.
+The remaining n-2 numbers are in the array but not sorted.
+Find the missing numbers The sum1 is the sum of all the elements in n.
+The sum2 is the sum of all the elements in n-2. sum1 - sum2 = num1 + num2 = s.
+The prod1 is the prod of all the elements in n. The prod2 is the prod of all
+the elements in n-2. prod1/prod2 = num1*num2 =p.
+Runtime is O(n), because it scan 3 times. Space is O(1)
+
+In case of finding one integer,  Let the missing number be M. We know that
+the sum of first N natural numbers is N*(N+1)/2. Traverse through the array
+once and calculate the sum. This is the sum of first N natural numbers -
+M or S=N*(N+1)/2 - M. Therefore M = N*(N+1)/2 - S.
+"""
+
+import math
+
+def find_two_missing_numbers(l1):
+    '''
+    >>> l1 = [1, 3, 5]
+    >>> find_two_missing_numbers(l1)
+    (4, 2)
+    '''
+
+    n_min_2 = len(l1)
+    n = n_min_2 + 2
+    sum1, sum2, prod1, prod2 = 0, 0, 1, 1
+    sum2 = sum(l1[:])
+    sum1 = sum(range(1,n+1))
+    s = sum1 - sum2
+
+    for i in range(1, n-1):
+        prod1 = prod1*i
+        prod2 = prod2*l1[i-1]
+
+    prod1 = prod1*n*(n-1)
+    p = prod1/prod2
+    num1 =  (s + math.sqrt(s*s - 4*p))/2
+    num2 =  (s - math.sqrt(s*s - 4*p))/2
+
+    return int(num1), int(num2)
+
+
+if __name__ == '__main__':
+    import doctest
+    doctest.testmod()
+
+
+
+
+
+

MY_BOOK/ebook_src/builtin_structures/get_float_rep_bin.py

@@ -0,0 +1,29 @@
+#!/usr/bin/env python
+
+__author__ = "bt3"
+
+
+''' Given a real number between 0 and 1 (eg: 0.72), this method print the
+    binary representation. If the Number cannot be represented accurately
+    in binary, with at exit most 32 chars, print error:
+'''
+
+def get_float_rep(num):
+    if num >= 1 or num <= 0: return 'Error 1'
+    result = '.'
+    while num:
+        if len(result) >= 32: return 'Error 2', result
+        r = num*2
+        if r >= 1:
+            result += '1'
+            num = r - 1
+        else:
+            result += '0'
+            num = r
+    return result
+
+
+if __name__ == '__main__':
+    print get_float_rep(0.72) #('Error 2', '.1011100001010001111010111000010')
+    print get_float_rep(0.1) # ('Error 2', '.0001100110011001100110011001100')
+    print get_float_rep(0.5) #'.1'

MY_BOOK/ebook_src/builtin_structures/interserction_two_arrays.py

@@ -0,0 +1,63 @@
+#!/usr/bin/env python
+
+__author__ = "bt3"
+
+
+def intersection_two_arrays_sets(seq1, seq2):
+    '''
+    >>> intersection_two_arrays_sets([1,2,3,5,7,8], [3,5,6])
+    set([3, 5])
+    >>> intersection_two_arrays_sets([1,2,7,8], [3,5,6])
+    set([])
+    '''
+    # O(n)
+    set1 = set(seq1)
+    set2 = set(seq2)
+
+    return set1.intersection(set2)  #same as list(set1 & set2)
+
+
+def intersection_two_arrays_On2(seq1, seq2):
+    '''
+    >>> intersection_two_arrays_On2([1,2,3,5,7,8], [3,5,6])
+    [3, 5]
+    >>> intersection_two_arrays_On2([1,2,7,8], [3,5,6])
+    []
+    '''
+
+    final = []
+
+    for i in seq1:
+        for j in seq2:
+            if i == j:
+                final.append(i)
+
+    return final
+
+
+def intersection_two_arrays_On(seq1, seq2):
+    '''
+    >>> intersection_two_arrays_On([1,2,3,5,7,8], [3,5,6])
+    [5, 3]
+    >>> intersection_two_arrays_On([1,2,7,8], [3,5,6])
+    []
+    '''
+
+    final = []
+
+    while seq1 and seq2:
+
+        if seq1[-1] == seq2[-1]:
+            final.append(seq1.pop())
+            seq2.pop()
+        elif seq1[-1] > seq2[-1]:
+            seq1.pop()
+        else:
+            seq2.pop()
+
+    return final
+
+
+if __name__ == '__main__':
+    import doctest
+    doctest.testmod()

MY_BOOK/ebook_src/builtin_structures/max_subarray_stocks.py

@@ -0,0 +1,54 @@
+#!/usr/bin/env python
+
+__author__ = "bt3"
+
+
+
+def beating_stock(array):
+
+    imin = 0
+
+    # first deal is just buying in the next day (1)
+    deal = [array[1] - array[imin], imin, 1]
+
+    for i, d in enumerate(array):
+
+        deal_here = d - array[imin]
+
+        if deal_here > deal[0]:
+            deal = [deal_here, imin, i]
+
+        elif d < array[imin]:
+            imin = i
+
+    return deal[0], array[deal[1]], array[deal[2]]
+
+
+def beating_stock2(array):
+
+    deal = 0
+    min_value = array[0]
+
+    for i, d in enumerate(array):
+
+        deal_here = d - min_value
+
+        if deal_here > deal:
+            deal = deal_here
+
+        else:
+            if min_value > array[i]:
+                min_value = array[i]
+
+    return deal
+
+
+
+if __name__ == '__main__':
+    array = [7, 2, 3, 6, 5, 8, 5, 3, 4]
+
+    deal = beating_stock(array)
+    print("Profit: %d, buying at %d, selling at %d." %(deal[0], deal[1], deal[2]))
+
+    deal = beating_stock2(array)
+    print "Profit: " + str(deal)

MY_BOOK/ebook_src/builtin_structures/number_of_zeros_factorial.txt

@@ -0,0 +1,15 @@
+#!/usr/bin/env python
+
+__author__ = "bt3"
+
+
+
+How to know how many 0 are in 100!
+
+You look for the primes that multiply to 10, i.e. 2 and 5.
+
+There are more 5 than 2s so you can count the fives.
+
+there is 100/5 = 20, so 20 5s. However, there are two 5s in 25, 50, 75 and 100.
+
+result: 20+4 = 24

MY_BOOK/ebook_src/builtin_structures/palindrome.py

@@ -0,0 +1,33 @@
+#!/usr/bin/env python
+
+__author__ = "bt3"
+
+
+
+from collections import defaultdict
+
+def is_palindrome(array):
+    '''
+    >>> is_palindrome('subi no onibus')
+    True
+    >>> is_palindrome('helllo there')
+    False
+    >>> is_palindrome('h')
+    True
+    >>> is_palindrome('')
+    True
+    '''
+    array = array.strip(' ')
+    if len(array) < 2:
+        return True
+
+    if array[0] == array[-1]:
+        return is_palindrome(array[1:-1])
+    else:
+        return False
+
+
+if __name__ == '__main__':
+    import doctest
+    doctest.testmod()
+

MY_BOOK/ebook_src/builtin_structures/permutations.py

@@ -0,0 +1,70 @@
+#!/usr/bin/env python
+
+__author__ = "bt3"
+
+
+
+def perm(str1):
+    '''
+    >>> perm('123')
+    ['123', '132', '231', '213', '312', '321']
+    '''
+
+    if len(str1) < 2:
+        return str1
+
+    res = []
+    for i, c in enumerate(str1):
+        for cc in perm(str1[i+1:] + str1[:i]):
+            res.append(c + cc)
+    return res
+
+
+def perm2(str1):
+    '''
+    >>> perm2('123')
+    ['123', '132', '213', '231', '312', '321']
+    '''
+    from itertools import permutations
+    return [''.join(p) for p in permutations(str1)]
+
+
+def ispermutation(s1, s2):
+    '''
+    >>> ispermutation('231', '123')
+    True
+    >>> ispermutation('231', '153')
+    False
+    '''
+
+    from collections import Counter
+    aux = Counter()
+    for i in s1:
+        aux[i] += 1
+    for i in s2:
+        aux[i] -= 1
+    for v in aux.values():
+        if v != 0:
+            return False
+    return True
+
+
+
+
+def ispermutation2(s1, s2):
+    '''
+    >>> ispermutation2('231', '123')
+    True
+    >>> ispermutation2('231', '153')
+    False
+    '''
+    if sorted(s1) == sorted(s2):
+        return True
+    else:
+        return False
+
+
+
+if __name__ == '__main__':
+    import doctest
+    doctest.testmod()

MY_BOOK/ebook_src/builtin_structures/permutations_alphanumeric.py

@@ -0,0 +1,37 @@
+#!/usr/bin/env python
+
+__author__ = "bt3"
+
+
+''' Write code to generate all possible case permutations of a given
+lower-cased string
+'''
+
+def alpha_permutation(string):
+    '''
+    >>> alpha_permutation('0ab')
+    ['0Ab', '0Ab', '0ab', '0ab', '0Ba', '0Ba', '0ba', '0ba', 'ab0', 'a0b', 'a0b', 'b0a', 'b0a', 'ba0']
+    >>> alpha_permutation('')
+    ''
+    '''
+
+    if len(string) < 2:
+        return string
+
+    result = []
+
+    for i, c in enumerate(string):
+        rest =  string[i+1:] + string[:i]
+        for cc in alpha_permutation(rest):
+            if cc.isalpha():
+                result.append(c.upper() + cc)
+            result.append(c + cc)
+
+    return result
+
+
+
+if __name__ == '__main__':
+    import doctest
+    doctest.testmod()
+

MY_BOOK/ebook_src/builtin_structures/primes.py

@@ -0,0 +1,47 @@
+#!/usr/bin/env python
+
+__author__ = "bt3"
+
+
+'''
+find prime factors of a number.
+'''
+
+import math
+import random
+
+def find_prime_factors(n):
+    '''
+    >>> find_prime_factors(14)
+    [2, 7]
+    >>> find_prime_factors(19)
+    []
+    '''
+
+    divisors = [d for d in range(2, n//2 + 1) if n % d == 0]
+    primes = [d for d in divisors if is_prime(d)]
+
+    return primes
+
+
+def is_prime(n):
+    for j in range(2, int(math.sqrt(n))):
+        if (n % j) == 0:
+            return False
+    return True
+
+
+''' return a n-bit prime '''
+def generate_prime(number=3):
+    while 1:
+        p = random.randint(pow(2, number-2), pow(2, number-1)-1)
+        p = 2 * p + 1
+        if find_prime_factors(p):
+            return p
+
+
+
+if __name__ == '__main__':
+    import doctest
+    doctest.testmod()
+

MY_BOOK/ebook_src/builtin_structures/prod_other_ints.py

@@ -0,0 +1,28 @@
+#!/usr/bin/env python
+
+__author__ = "bt3"
+
+
+def get_products_of_all_except_at_index(array):
+    '''
+    >>> a = [1, 7, 3, 4]
+    >>> get_products_of_all_except_at_index(a)
+    [84, 12, 28, 21]
+    '''
+    total = 1
+    for n in array:
+        total *= n
+
+    new_array = []
+    for n in array:
+        if n is not 0:
+            item = total/n
+            new_array.append(item)
+        else:
+            new_array.append(n)
+
+    return new_array
+
+if __name__ == '__main__':
+    import doctest
+    doctest.testmod()

MY_BOOK/ebook_src/builtin_structures/ransom_note.py

@@ -0,0 +1,34 @@
+#!/usr/bin/env python
+
+__author__ = "bt3"
+
+
+
+from collections import Counter
+
+def check_if_ransom_note(magazines, note):
+    count = Counter()
+    pm, pn = 0, 0
+
+    while pn < len(note) and pm < len(magazines):
+        char_note = note[pn]
+        if count[char_note]>0:
+            count[char_note] -= 1
+            pn += 1
+        else:
+            char_magazine = magazines[pm]
+            count[char_magazine] += 1
+            pm +=1
+
+    return pn == len(note)
+
+
+
+if __name__ == '__main__':
+
+    magazines1 = "avfegthhgrebvkdsvnijnvyijfdmckdsmovkmmfvskumvl;cdkmioswckofjbkreenyukjemjgnmkmvkmnvdkmvkr g gmvdvmldm vldfkmbldkmlvdkm"
+    magazines2 = "adfsfa"
+    note = "you should disobey"
+
+    print(check_if_ransom_note(magazines1, note))
+    print(check_if_ransom_note(magazines2, note))

MY_BOOK/ebook_src/builtin_structures/reverse_string.py

@@ -0,0 +1,37 @@
+#!/usr/bin/env python
+
+__author__ = "bt3"
+
+
+def revert(string):
+    '''
+    >>> s = 'hello'
+    >>> revert(s)
+    'olleh'
+    >>> revert('')
+    ''
+    '''
+    return string[::-1]
+
+
+
+def reverse_string_inplace(s):
+    '''
+    >>> s = 'hello'
+    >>> reverse_string_inplace(s)
+    'olleh'
+    >>> reverse_string_inplace('')
+    ''
+    '''
+    if s:
+        s = s[-1] + reverse_string_inplace(s[:-1])
+    return s
+
+
+
+
+
+
+if __name__ == '__main__':
+    import doctest
+    doctest.testmod()

MY_BOOK/ebook_src/builtin_structures/reverse_words.py

@@ -0,0 +1,45 @@
+#!/usr/bin/env python
+
+__author__ = "bt3"
+
+
+
+def reversing_words(word):
+    """
+    >>> reversing_words('buffy is awesome')
+    'awesome is buffy'
+    """
+    new_word = []
+
+    words = word.split(' ')
+    for word in words[::-1]:
+        new_word.append(word)
+
+    return " ".join(new_word)
+
+
+def reversing_words2(s):
+    """
+    >>> reversing_words2('buffy is awesome')
+    'awesome is buffy'
+    """
+    words = s.split()
+    return ' '.join(reversed(words))
+
+
+def reversing_words3(s):
+    """
+    >>> reversing_words('buffy is awesome')
+    'awesome is buffy'
+    """
+    words = s.split(' ')
+    words.reverse()
+    return ' '.join(words)
+
+
+
+
+if __name__ == '__main__':
+    import doctest
+    doctest.testmod()
+

MY_BOOK/ebook_src/builtin_structures/rotate_NxN.py

@@ -1,8 +1,7 @@
-#!/usr/bin/python3
-# mari von steinkirch @2013
-# steinkirch at gmail
+#!/usr/bin/env python
+
+__author__ = "bt3"
 
-   
 def rotate_NxN(m):
     n = len(m)
     for layer in range(n//2):
@@ -16,7 +15,7 @@ def rotate_NxN(m):
             m[last][last-offset] = m[i][last]
             m[i][last] = top
     return m
-    
+
 
 
 def main():
@@ -25,7 +24,7 @@ def main():
     assert(rotate_NxN(m) == mr)
     m2 = [[1,2,3],[4,5,6],[7,8,9]]
     print(rotate_NxN(m2))
-                   
+
 if __name__ == '__main__':
     main()
 

MY_BOOK/ebook_src/builtin_structures/runtime_dicts_with_timeit_module.py

@@ -1,9 +1,19 @@
-#!/usr/bin/python3
-# mari von steinkirch @2013
-# steinkirch at gmail
+#!/usr/bin/env python
 
+__author__ = "bt3"
 
-'''To use timeit you create a Timer object whose parameters are two Python statements. The first parameter is a Python statement that you want to time; the second parameter is a statement that will run once to set up the test. The timeit module will then time how long it takes to execute the statement some number of times. By default timeit will try to run the statement one million times. When its done it returns the time as a floating point value representing the total number of seconds. However, since it executes the statement a million times you can read the result as the number of microseconds to execute the test one time. You can also pass timeit a named parameter called number that allows you to specify how many times the test statement is executed. The following session shows how long it takes to run each of our test functions 1000 times. '''
+'''To use timeit you create a Timer object whose parameters are two Python
+statements. The first parameter is a Python statement that you want to time;
+the second parameter is a statement that will run once to set up the test.
+The timeit module will then time how long it takes to execute the statement
+some number of times. By default timeit will try to run the statement one
+million times. When its done it returns the time as a floating point value
+representing the total number of seconds. However, since it executes the
+statement a million times you can read the result as the number of
+microseconds to execute the test one time. You can also pass timeit a
+named parameter called number that allows you to specify how many times the
+test statement is executed. The following session shows how long it takes to
+run each of our test functions 1000 times. '''
 
 
 import timeit
@@ -19,7 +29,7 @@ for i in range(10000,1000001,20000):
     print("%d,%10.3f,%10.3f" % (i, lst_time, d_time))
 
 
-""" There rersults are:
+""" There results are:
 10000,     0.192,     0.002
 30000,     0.600,     0.002
 50000,     1.000,     0.002

MY_BOOK/ebook_src/builtin_structures/runtime_lists_with_timeit_module.py

@@ -1,7 +1,6 @@
-#!/usr/bin/python3
-# mari von steinkirch @2013
-# steinkirch at gmail
+#!/usr/bin/env python
 
+__author__ = "bt3"
 
 '''To use timeit you create a Timer object whose parameters are two Python statements. The first parameter is a Python statement that you want to time; the second parameter is a statement that will run once to set up the test. The timeit module will then time how long it takes to execute the statement some number of times. By default timeit will try to run the statement one million times. When its done it returns the time as a floating point value representing the total number of seconds. However, since it executes the statement a million times you can read the result as the number of microseconds to execute the test one time. You can also pass timeit a named parameter called number that allows you to specify how many times the test statement is executed. The following session shows how long it takes to run each of our test functions 1000 times. '''
 

MY_BOOK/ebook_src/builtin_structures/search_entry_matrix.py

@@ -1,18 +1,22 @@
-#!/usr/bin/python3
-# mari von steinkirch @2013
-# steinkirch at gmail
+#!/usr/bin/env python
+
+__author__ = "bt3"
 
 
+''' Search an Entry in a Matrix where the Rows and columns are Sorted
+        In this 2D matrix, every row is increasingly sorted from left to right,
+        and every column is increasingly sorted from top to bottom.
+        The runtime is O(m+n).
+'''
 
 def find_elem_matrix_bool(m1, value):
-    ''' Search an Entry in a Matrix where the Rows and columns are Sorted
-        In this 2D matrix, every row is increasingly sorted from left to right, 
-        and every column is increasingly sorted from top to bottom. 
-        The runtime is O(m+n). '''
+
     found = False
     row = 0
     col = len(m1[0]) - 1
+
     while row < len(m1) and col >= 0:
+
         if m1[row][col] == value:
             found = True
             break
@@ -20,8 +24,9 @@ def find_elem_matrix_bool(m1, value):
             col-=1
         else:
             row+=1
+
     return found
-    
+
 
 
 def test_find_elem_matrix_bool(module_name='this module'):
@@ -30,9 +35,6 @@ def test_find_elem_matrix_bool(module_name='this module'):
     assert(find_elem_matrix_bool(m1,3) == False)
     m2 = [[0]]
     assert(find_elem_matrix_bool(m2,0) == True)
-        
-    s = 'Tests in {name} have {con}!'
-    print(s.format(name=module_name, con='passed'))
 
 
 if __name__ == '__main__':

MY_BOOK/ebook_src/builtin_structures/simple_str_comprension.py

@@ -1,11 +1,19 @@
-#!/usr/bin/python3
-# mari von steinkirch @2013
-# steinkirch at gmail
+#!/usr/bin/env python
+
+__author__ = "bt3"
+
 
-   
 from collections import Counter
+
 def str_comp(s):
-    ''' basic str compression with counts of repeated char'''
+    '''
+    >>> s1 = 'aabcccccaaa'
+    >>> str_comp(s1)
+    'a2b1c5a3'
+    >>> str_comp('')
+    ''
+    '''
+
     count, last = 1, ''
     list_aux = []
     for i, c in enumerate(s):
@@ -17,16 +25,10 @@ def str_comp(s):
             list_aux.append(c)
             count = 1
             last = c
-    list_aux.append(str(count))    
+    list_aux.append(str(count))
     return ''.join(list_aux)
-        
 
-def main():
-    s1 = 'aabcccccaaa'
-    s2 = ''
-    print(str_comp(s1)) # 'a2b1c5a3'
-    print(str_comp(s2))
-                   
+
 if __name__ == '__main__':
-    main()
-
+    import doctest
+    doctest.testmod()

MY_BOOK/ebook_src/builtin_structures/sum_two_numbers_as_strings.py

@@ -0,0 +1,41 @@
+#!/usr/bin/env python
+
+__author__ = "bt3"
+
+
+'''
+find the sum of two integers represented as strings,
+return the sum as string, i.e "123" and "456" would return "579"
+'''
+
+
+def get_number(s):
+    count = 1
+    num = 0
+    p = len(s) -1
+    while p >= 0:
+        num = num + int(s[p])*count
+        count *= 10
+        p -= 1
+    return num
+
+
+def sum_string(s1, s2):
+    '''
+    >>> sum_string('10', '5')
+    '15'
+    >>> sum_string('0', '1')
+    '1'
+    >>> sum_string('123', '456')
+    '579'
+    '''
+
+    n1 = get_number(s1)
+    n2 = get_number(s2)
+    return str(n2 + n1)
+
+
+if __name__ == '__main__':
+    import doctest
+    doctest.testmod()
+

MY_BOOK/ebook_src/dynamic_programming/memo.py

@@ -1,6 +1,6 @@
 #!/usr/bin/python3
-# mari von steinkirch @2013
-# steinkirch at gmail
+
+__author__ = "bt3"
 
 
 from functools import wraps
@@ -20,7 +20,7 @@ def memo(func):
 def find_fibonacci_seq_rec(n):
     ''' implements the nth fibonacci value in a recursive exponential runtime '''
     if n < 2: return n
-    return find_fibonacci_seq_rec(n - 1) + find_fibonacci_seq_rec(n - 2)   
+    return find_fibonacci_seq_rec(n - 1) + find_fibonacci_seq_rec(n - 2)
 
 def test_memo():
     n = 50
@@ -31,9 +31,9 @@ def test_memo():
 
 if __name__ == '__main__':
     test_memo()
-    
-    
-   
+
+
+
 
 
 

MY_BOOK/ebook_src/dynamic_programming/memoized_longest_inc_subseq.py

@@ -1,7 +1,6 @@
 #!/usr/bin/python3
-# mari von steinkirch @2013
-# steinkirch at gmail
 
+__author__ = "bt3"
 
 from itertools import combinations
 from bisect import bisect
@@ -14,7 +13,7 @@ def naive_longest_inc_subseq(seq):
         for sub in combinations(seq, length):
             if list(sub) == sorted(sub):
                 return len(sub)
-                       
+
 
 def longest_inc_subseq1(seq):
     ''' an iterative algorithm for the longest increasing subsequence problem '''
@@ -24,8 +23,8 @@ def longest_inc_subseq1(seq):
         if idx == len(end): end.append(val)
         else: end[idx] = val
     return len(end)
-    
-    
+
+
 def longest_inc_subseq2(seq):
     ''' another iterative algorithm for the longest increasing subsequence problem '''
     L = [1] * len(seq)
@@ -51,17 +50,17 @@ def memoized_longest_inc_subseq(seq):
 @benchmark
 def test_naive_longest_inc_subseq():
     print(naive_longest_inc_subseq(s1))
-    
+
 benchmark
-def test_longest_inc_subseq1():   
+def test_longest_inc_subseq1():
     print(longest_inc_subseq1(s1))
 
 @benchmark
-def test_longest_inc_subseq2():  
+def test_longest_inc_subseq2():
     print(longest_inc_subseq2(s1))
- 
+
 @benchmark
-def test_memoized_longest_inc_subseq(): 
+def test_memoized_longest_inc_subseq():
     print(memoized_longest_inc_subseq(s1))
 
 
@@ -73,9 +72,9 @@ if __name__ == '__main__':
     test_longest_inc_subseq1()
     test_longest_inc_subseq2()
     test_memoized_longest_inc_subseq()
-    
-    
-   
+
+
+
 
 
 

MY_BOOK/ebook_src/manipulating_files/change_ext_file.py

@@ -1,6 +1,8 @@
-#!/usr/bin/python3
-# mari von steinkirch @2013
-# steinkirch at gmail
+#!/usr/bin/env python
+
+
+__author__ = "bt3"
+
 
 import os
 import sys
@@ -12,12 +14,12 @@ def change_file_ext():
         print("Usage: change_ext.py filename.old_ext 'new_ext'")
         sys.exit()
 
-    name = os.path.splitext(sys.argv[1])[0] + "." + sys.argv[2] 
+    name = os.path.splitext(sys.argv[1])[0] + "." + sys.argv[2]
     print (name)
-	
+
     try:
-        shutil.copyfile(sys.argv[1], name)			
-    except OSError as err:	
+        shutil.copyfile(sys.argv[1], name)
+    except OSError as err:
         print (err)
 
 

MY_BOOK/ebook_src/manipulating_files/count_unique_words_files.py

@@ -1,24 +1,28 @@
-#!/usr/bin/python3
-# mari von steinkirch @2013
-# steinkirch at gmail
+#!/usr/bin/python
 
+__author__ = "bt3"
+
+
+import collections
 import string
 import sys
 
-def count_unique_word():
-    ''' list every word and number of times in alphabetical order for input files ''' 
-    words = {} # create an empty dictionary
-    strip = string.whitespace + string.punctuation + string.digits + "\"'" 
+def count_unique_word_file():
+    if len(sys.argv) < 2:
+        print "Usage: python count_unique_word.py NAMEFILE"
+
+    words = collections.defaultdict(int)
+    strip = string.whitespace + string.punctuation + string.digits + "\"'"
     for filename in sys.argv[1:]:
         with open(filename) as file:
-            for line in file:	
+            for line in file:
                 for word in line.lower().split():
                     word = word.strip(strip)
                     if len(word) > 2:
-                        words[word] = words.get(word,0) +1
+                        words[word] = +1
     for word in sorted(words):
         print("'{0}' occurs {1} times.".format(word, words[word]))
 
 
-count_unique_word()
-        
+if __name__ == '__main__':
+    count_unique_word_file()

MY_BOOK/ebook_src/manipulating_files/count_unique_words_frequency.py

@@ -0,0 +1,15 @@
+#!/usr/bin/python
+
+__author__ = "bt3"
+
+
+import collections
+import sys
+
+def count_unique_word_freq():
+        return collections.Counter(\
+            sys.stdin.read().lower().split()).most_common(n)
+
+
+if __name__ == '__main__':
+    count_unique_word_freq()

MY_BOOK/ebook_src/manipulating_files/grep_word_from_files.py

@@ -1,6 +1,7 @@
-#!/usr/bin/python3
-# mari von steinkirch @2013
-# steinkirch at gmail
+#!/usr/bin/env python
+
+
+__author__ = "bt3"
 
 import sys
 
@@ -13,7 +14,7 @@ def grep_word_from_files():
                 if word in line:
                     print("{0}:{1}:{2:.40}".format(filename, lino, line.rstrip()))
 
-            
+
 if __name__ == '__main__':
     if len(sys.argv) < 2:
         print("Usage: grep_word_from_files.py word infile1 [infile2...]")