Merge branch 'master' of https://github.com/IanDoarn/pygorithm into IanDoarn-master

'New
'

Author: OmkarPathak

pygorithm/__init__.py

@@ -68,7 +68,7 @@
     'math',
     'searching',
     'sorting',
-    'string',
+    'strings',
     'pathfinding'
     'geometry',
     'greedy_algorithm'

pygorithm/binary/ascii.py

@@ -7,6 +7,7 @@
 
 Author: Ian Doarn
 """
+from pygorithm.binary.binary_utils import pad
 from pygorithm.binary.base10 import to_base2 as b10_to_b2
 from pygorithm.binary.base2 import to_base16 as b2_to_b16, \
     to_ascii as b2_to_ascii
@@ -47,7 +48,8 @@ def to_base2(string, visualize=False, as_string=False):
                 x, str(ord(x)),
                 str(b10_to_b2(ord(x)))
             ))
-        _list.append(str(b10_to_b2(ord(x))))
+        value = pad(str(b10_to_b2(ord(x))))
+        _list.append(value)
 
     if as_string:
         return ' '.join(_list)

pygorithm/binary/base10.py

@@ -62,7 +62,7 @@ def to_base16(n, visualize=False):
             print("{} % 16 = {} -> hex = {}".format(
                 str(n), str(n % 16), HEX_VALUES[n % 16]
             ))
-            _list.append(HEX_VALUES[n % 16])
+        _list.append(HEX_VALUES[n % 16])
         n = int(n / 16)
 
     if visualize:

pygorithm/binary/base16.py

@@ -9,6 +9,7 @@
 Author: Ian Doarn
 """
 from pygorithm.binary.base2 import to_ascii as b2_to_ascii
+from pygorithm.binary.binary_utils import pad
 from math import pow
 
 HEX_BINARY_VALUES = {
@@ -45,7 +46,7 @@ def to_base2(h, visualize=False):
             print("{} -> {}".format(
                 value, HEX_BINARY_VALUES[value]
             ))
-        _list.append(HEX_BINARY_VALUES[value])
+        _list.append(pad(HEX_BINARY_VALUES[value]))
 
     return int(''.join(_list))
 

pygorithm/binary/binary_utils.py

@@ -0,0 +1,16 @@
+"""
+Helper methods for binary package
+Author: Ian Doarn
+"""
+
+
+def pad(value: str, return_type=str) -> """Pad binary value with zeros""":
+    if len(value) % 4 != 0:
+        pad_amount = 4 - (len(value) % 4)
+        return return_type(('0' * pad_amount) + value)
+    else:
+        return return_type(value)
+
+
+def to_string(binary_array: list, delimiter=' ') -> """Convert binary array to string""":
+    return delimiter.join(binary_array)

pygorithm/dynamic_programming/__init__.py

@@ -6,5 +6,5 @@
 
 __all__ = [
     'binary_knapsack',
-    'lis',
+    'lis'
 ]

pygorithm/dynamic_programming/binary_knapsack.py

@@ -1,16 +1,17 @@
-'''
+"""
 Author: Omkar Pathak
 Created At: 25th August 2017
-'''
-
+"""
 import inspect
+# TODO: Explain how this works / Explain what a knapsack is
+
 
-def knapsack(W, value, weight):
-    '''
-        :param W: maximum weight capacity
-        :param value: an array of values of items in the knapsack
-        :param weight: an array of weights of items in the knapsack
-    '''
+def knapsack(w, value, weight):
+    """
+    :param w: maximum weight capacity
+    :param value: an array of values of items in the knapsack
+    :param weight: an array of weights of items in the knapsack
+    """
     if type(value) is not list:
         raise TypeError("binary knapsack only accepts lists, not {}".format(str(type(value))))
     if type(weight) is not list:
@@ -22,13 +23,13 @@ def knapsack(W, value, weight):
     # n = number of items
     n = len(value)
 
-    knap_sack = [[0 for x in range(W+1)] for x in range(n+1)]
+    knap_sack = [[0 for _ in range(w+1)] for _ in range(n+1)]
 
-    for j in range(W + 1):
+    for j in range(w + 1):
         knap_sack[0][j] = 0
 
     for i in range(n + 1):
-        for w in range(W + 1):
+        for w in range(w + 1):
             if weight[i - 1] <= w:
                 knap_sack[i][w] = max(value[i - 1] + knap_sack[i - 1][w - weight[i - 1]], knap_sack[i - 1][w])
             else:

pygorithm/dynamic_programming/lis.py

@@ -1,28 +1,29 @@
-'''
+"""
 Author: Omkar Pathak
 Created At: 25th August 2017
-'''
+"""
+
 
 def longest_increasing_subsequence(_list):
-    '''
+    """
     The Longest Increasing Subsequence (LIS) problem is to find the length of the longest subsequence of a
     given sequence such that all elements of the subsequence are sorted in increasing order. For example,
     the length of LIS for {10, 22, 9, 33, 21, 50, 41, 60, 80} is 6 and LIS is {10, 22, 33, 50, 60, 80}.
-    '''
+    :param _list:
+    :return:
+    """
     # Initialize list with some value
     lis = [1] * len(_list)
     # list for storing the elements in an lis
     elements = [0] * len(_list)
 
     # Compute optimized LIS values in bottom up manner
-    for i in range (1 , len(_list)):
-        for j in range(0 , i):
-            if _list[i] > _list[j] and lis[i]< lis[j] + 1:
+    for i in range(1, len(_list)):
+        for j in range(0, i):
+            if _list[i] > _list[j] and lis[i] < lis[j] + 1:
                 lis[i] = lis[j]+1
                 elements[i] = j
 
-    idx = 0
-
     # find the maximum of the whole list and get its index in idx
     maximum = max(lis)
     idx = lis.index(maximum)
@@ -35,6 +36,7 @@ def longest_increasing_subsequence(_list):
 
     return (maximum, seq[::-1])
 
+
 def get_code():
     """
     returns the code for the longest_increasing_subsequence function

pygorithm/greedy_algorithm/__init__.py

@@ -6,5 +6,5 @@
 
 __all__ = [
     'fractional_knapsack',
-    'activity_selection',
+    'activity_selection'
 ]

pygorithm/greedy_algorithm/activity_selection.py

@@ -2,8 +2,9 @@
 Author: OMKAR PATHAK
 Created On: 26th August 2017
 """
-
 import inspect
+# TODO: Explain what this is / how it works
+
 
 def activity_selection(start_times, finish_times):
     """
@@ -37,6 +38,7 @@ def activity_selection(start_times, finish_times):
 
     return activity
 
+
 def get_code():
     """
     returns the code for the activity_selection function