Merge pull request #34 from IanDoarn/master

PEP8 compliance updates and updates to __init__.py files [enhancement]

Author: OmkarPathak

CONTIRBUTORS.md

@@ -0,0 +1,14 @@
+# Contributors:
+
+ - Mohamed 'MohamedKiouaz' Kiouaz
+ - Ashutosh 'ashu01' Gupta
+ - Allston 'AllstonMickey' Mickey
+ - Dmytro 'dmytrostriletskyi' Striletskyi
+ - Emett 'the-kid89' Speer
+ - Viktor 'vhag' Hagstrom
+ - Dion 'kingdion' Misic
+ - Chandan 'crowchirp' Rai
+ - Jae Hyeon 'skystar-p' Park
+ - dstark85
+ - Songzhuozhuo 'souo'
+ - Emil 'Skeen' Madsen

pygorithm/__init__.py

@@ -0,0 +1,66 @@
+"""
+Pygorithm
+
+A Python module to learn all the major algorithms on the go!
+Purely for educational purposes
+
+If you have found my software to be of any use to you,
+do consider helping me pay my internet bills.
+This would encourage me to create many such softwares :)
+
+PayPal -> https://paypal.me/omkarpathak27
+INR - > https://www.instamojo.com/@omkarpathak/
+
+CONTRIBUTORS:
+
+Mohamed 'MohamedKiouaz' Kiouaz
+Ashutosh 'ashu01' Gupta
+Allston 'AllstonMickey' Mickey
+Dmytro 'dmytrostriletskyi' Striletskyi
+Emett 'the-kid89' Speer
+Viktor 'vhag' Hagstrom
+Dion 'kingdion' Misic
+Chandan 'crowchirp' Rai
+Jae Hyeon 'skystar-p' Park
+dstark85
+Songzhuozhuo 'souo'
+Emil 'Skeen' Madsen
+
+"""
+from pygorithm import data_structures
+from pygorithm import fibonacci
+from pygorithm import math
+from pygorithm import searching
+from pygorithm import sorting
+
+__version__ = '1.0.0'
+__author__ = 'Omkar Pathak'
+
+# List maintainers here
+__maintainers__ = [
+    'Omkar Pathak'
+]
+# List contributors here
+__contributors__ = [
+	"Omkar 'OmkarPathak' Pathak"
+    "Mohamed 'MohamedKiouaz' Kiouaz",
+    "Ashutosh 'ashu01' Gupta",
+    "Allston 'AllstonMickey' Mickey",
+    "Dmytro 'dmytrostriletskyi' Striletskyi",
+    "Emett 'the-kid89' Speer",
+    "Viktor 'vhag' Hagstrom",
+    "Dion 'kingdion' Misic",
+    "Chandan 'crowchirp' Rai",
+    "Jae Hyeon 'skystar-p' Park",
+    "dstark85",
+    "Songzhuozhuo 'souo'",
+    "Emil 'Skeen' Madsen"
+]
+
+__all__ = [
+    'data_structures',
+   'fibonacci',
+   'math',
+   'searching',
+   'sorting'
+]

pygorithm/data_structures/__init__.py

@@ -1 +1,15 @@
-from . modules import modules
+from . import graph
+from . import heap
+from . import linked_list
+from . import queue
+from . import stack
+from . import tree
+
+__all__ = [
+    'graph',
+    'heap',
+    'linked_list',
+    'queue',
+    'stack',
+    'tree'
+]

pygorithm/fibonacci/__init__.py

@@ -1,5 +1,15 @@
-from pygorithm.fibonacci import generator
-from pygorithm.fibonacci import goldenratio
-from pygorithm.fibonacci import memoization
-from pygorithm.fibonacci.modules import modules
-from pygorithm.fibonacci import recursion
+"""
+Collection of fibonacci methods and functions
+"""
+from . import generator
+from . import goldenratio
+from . import memoization
+from . import modules
+from . import recursion
+
+__all__ = [
+    'generator',
+    'goldenratio',
+    'memoization',
+    'recursion'
+]

pygorithm/math/__init__.py

@@ -1 +1,12 @@
-from . modules import modules
+"""
+Collection of special math functions
+"""
+from . import lcm
+from . import lcm_using_gcd
+from . import sieve_of_eratosthenes
+
+__all__ = [
+    'lcm',
+    'lcm_using_gcd',
+    'sieve_of_eratosthenes'
+]

pygorithm/searching/__init__.py

@@ -1 +1,16 @@
-from . modules import modules
+"""
+Collection of searching algorithms
+"""
+from . import binary_search
+from . import breadth_first_search
+from . import depth_first_search
+from . import linear_search
+from . import quick_select
+
+__all__ = [
+    'binary_search',
+    'breadth_first_search',
+    'depth_first_search',
+    'linear_search',
+    'quick_select'
+]

pygorithm/sorting/__init__.py

@@ -1 +1,24 @@
-from . modules import modules
+"""
+Collection of sorting methods
+"""
+from . import quick_sort
+from . import bucket_sort
+from . import bubble_sort
+from . import heap_sort
+from . import counting_sort
+from . import insertion_sort
+from . import merge_sort
+from . import selection_sort
+from . import shell_sort
+
+__all__ = [
+    'bubble_sort',
+    'bucket_sort',
+    'counting_sort',
+    'heap_sort',
+    'insertion_sort',
+    'merge_sort',
+    'quick_sort',
+    'selection_sort',
+    'shell_sort'
+]

pygorithm/sorting/bubble_sort.py

@@ -1,39 +1,63 @@
-# Author: OMKAR PATHAK
-# Contributors: Mohamed Kiouaz
-# Created On: 31st July 2017
-
-# Best O(n); Average O(n*(n-1)/4); Worst O(n^2)
-
-# Bubble Sorting algorithm
-def sort(List):
-    for i in range(len(List)):
-        for j in range(len(List) - 1, i, -1):
-            if List[j] < List[j - 1]:
-                List[j], List[j - 1] = List[j - 1], List[j]
-    return List
-
-# Improved Bubble Sorting algorithm
-def improved_sort(List):
-    for i in range(len(List)):
+"""
+Author: OMKAR PATHAK
+Contributors: Mohamed Kiouaz
+Created On: 31st July 2017
+
+Best O(n); Average O(n*(n-1)/4); Worst O(n^2)
+"""
+import inspect
+
+
+def sort(_list):
+    """
+    Bubble Sorting algorithm
+
+    :param _list: list of values to sort
+    :return: sorted values
+    """
+    for i in range(len(_list)):
+        for j in range(len(_list) - 1, i, -1):
+            if _list[j] < _list[j - 1]:
+                _list[j], _list[j - 1] = _list[j - 1], _list[j]
+    return _list
+
+
+def improved_sort(_list):
+    """
+    Improved Bubble Sorting algorithm
+
+    :param _list: list of values to sort
+    :return: sorted values
+    """
+    for i in range(len(_list)):
         stop = True
-        for j in range(len(List) - 1, i, -1):
-            if List[j] < List[j - 1]:
+        for j in range(len(_list) - 1, i, -1):
+            if _list[j] < _list[j - 1]:
                 stop = False
-                List[j], List[j - 1] = List[j - 1], List[j]
-        if(stop == True):
-            return List
-    return List
+                _list[j], _list[j - 1] = _list[j - 1], _list[j]
+        if stop:
+            return _list
+    return _list
+
 
-# time complexities
+# TODO: Are these necessary?
 def time_complexities():
-    return '''Best Case: O(n) , Average Case: O(n ^ 2), Worst Case: O(n ^ 2) \n For Improved Bubble Sort: \n Best Case: O(n); Average Case: O(n * (n - 1) / 4); Worst Case: O(n ^ 2) '''
+    """
+    Return information on functions
+    time complexity
+    :return: string
+    """
+    return "Best Case: O(n), " \
+           "Average Case: O(n ^ 2), " \
+           "Worst Case: O(n ^ 2).\n\n" \
+           "For Improved Bubble Sort:\nBest Case: O(n); Average Case: O(n * (n - 1) / 4); Worst Case: O(n ^ 2)"
+
 
-# easily retrieve the source code of the sort function
 def get_code():
-    import inspect
-    return inspect.getsource(sort)
+    """
+    easily retrieve the source code
+    of the sort function
 
-# easily retrieve the source code of the sort function
-def get_improved_code():
-    import inspect
-    return inspect.getsource(improved_sort)
+    :return: source code
+    """
+    return inspect.getsource(sort)

pygorithm/sorting/bucket_sort.py

@@ -1,58 +1,83 @@
-# Author: OMKAR PATHAK
-# Created On: 31st July 2017
+"""
+Author: OMKAR PATHAK
+Created On: 31st July 2017
 
-# Best O(n); Average O(n); Worst O(n)
+ - Best O(n)
+ - Average O(n)
+ - Worst O(n)
+"""
+import math
+from pygorithm.sorting import insertion_sort
+import inspect
 
-# bucket sort algorithm
-def sort(List, bucketSize = 5):
-    from pygorithm.sorting import insertion_sort
-    import math
 
+def sort(_list, bucket_size=5):
+    """
+    bucket sort algorithm
+    
+    :param _list: list of values to sort
+    :param bucket_size: Size of the bucket
+    :return: sorted values
+    """
     string = False
 
-    if(len(List) == 0):
-        print('You don\'t have any elements in array!')
-    elif all(isinstance(element, str) for element in List):
+    if len(_list) == 0:
+        # print("You don\'t have any elements in array!")
+        raise ValueError("Array can not be empty.")
+    
+    elif all(isinstance(element, str) for element in _list):
         string = True
-        List = [ord(element) for element in List]
+        _list = [ord(element) for element in _list]
 
-    minValue = List[0]
-    maxValue = List[0]
+    min_value = _list[0]
+    max_value = _list[0]
 
     # For finding minimum and maximum values
-    for i in range(0, len(List)):
-        if List[i] < minValue:
-            minValue = List[i]
-        elif List[i] > maxValue:
-            maxValue = List[i]
+    for i in range(0, len(_list)):
+        if _list[i] < min_value:
+            min_value = _list[i]
+        elif _list[i] > max_value:
+            max_value = _list[i]
 
     # Initialize buckets
-    bucketCount = math.floor((maxValue - minValue) / bucketSize) + 1
+    bucket_count = math.floor((max_value - min_value) / bucket_size) + 1
     buckets = []
-    for i in range(0, bucketCount):
+    for i in range(0, int(bucket_count)):
         buckets.append([])
 
     # For putting values in buckets
-    for i in range(0, len(List)):
-        buckets[math.floor((List[i] - minValue) / bucketSize)].append(List[i])
+    for i in range(0, len(_list)):
+        # TODO: floor expects floats but could be receiving int or slice
+        buckets[math.floor(float((_list[i] - min_value) / bucket_size))].append(_list[i])
 
     # Sort buckets and place back into input array
-    sortedArray = []
+    sorted_array = []
     for i in range(0, len(buckets)):
         insertion_sort.sort(buckets[i])
         for j in range(0, len(buckets[i])):
-            sortedArray.append(buckets[i][j])
+            sorted_array.append(buckets[i][j])
 
     if string:
-        return [chr(element) for element in sortedArray]
+        return [chr(element) for element in sorted_array]
     else:
-        return sortedArray
+        return sorted_array
 
-# time complexities
+
+# TODO: Are these necessary?
 def time_complexities():
-    return '''Best Case: O(n), Average Case: O(n), Worst Case: O(n)'''
+    """
+    Return information on functions
+    time complexity
+    :return: string
+    """
+    return "Best Case: O(n), Average Case: O(n), Worst Case: O(n)"
+
 
-# easily retrieve the source code of the sort function
 def get_code():
-    import inspect
+    """
+    easily retrieve the source code
+    of the sort function
+
+    :return: source code
+    """
     return inspect.getsource(sort)