Merge docs/index.rst

Author: Tjstretchalot

docs/DynamicP.rst

@@ -0,0 +1,43 @@
+===================
+Dynamic Programming
+===================
+
+A place for implementation of greedy algorithms
+
+Features
+--------
+
+* To see all the available functions in a module, you can just type ``help()`` with the module name as argument. For example,
+
+.. code:: python
+
+    >>> from pygorithm import greedy_algorithm
+    >>> help(greedy_algorithm)
+        Help on package pygorithm.dynamic_programming in pygorithm:
+
+        NAME
+        pygorithm.dynamic_programming - Collection for dynamic programming algorithms
+
+        PACKAGE CONTENTS
+        binary_knapsack
+        lis
+
+        DATA
+        __all__ = ['binary_knapsack', 'lis']
+
+
+Binary (0/1) Knapsack
+---------------------
+
+* Functions and their uses
+
+.. automodule:: pygorithm.dynamic_programming.binary_knapsack
+   :members:
+
+Longest Increasing Subsequence
+------------------------------
+
+* Functions and their uses
+
+.. automodule:: pygorithm.dynamic_programming.lis
+   :members:

docs/Greedy.rst

@@ -0,0 +1,43 @@
+=================
+Greedy Algorithms
+=================
+
+A place for implementation of greedy algorithms
+
+Features
+--------
+
+* To see all the available functions in a module, you can just type ``help()`` with the module name as argument. For example,
+
+.. code:: python
+
+    >>> from pygorithm import greedy_algorithm
+    >>> help(greedy_algorithm)
+        Help on package pygorithm.greedy_algorithm in pygorithm:
+
+        NAME
+        pygorithm.greedy_algorithm - Collection for greedy algorithms
+
+        PACKAGE CONTENTS
+        activity_selection
+        fractional_knapsack
+
+        DATA
+        __all__ = ['fractional_knapsack', 'activity_selection']
+
+
+Activity Selection Problem
+--------------------------
+
+* Functions and their uses
+
+.. automodule:: pygorithm.greedy_algorithm.activity_selection
+   :members:
+
+Fractional Knapsack
+-------------------
+
+* Functions and their uses
+
+.. automodule:: pygorithm.greedy_algorithm.fractional_knapsack
+   :members:

docs/index.rst

@@ -22,13 +22,16 @@ Quick Links
    :maxdepth: 2
    :caption: Documentation:
 
-   Sorting
-   Searching
    Data_Structure
+   DynamicP
    Fibonacci
+   Greedy
    Math
    Pathfinding
    Geometry
+   Searching
+   Sorting
+   strings
 
 Quick Start Guide
 -----------------

docs/strings.rst

@@ -0,0 +1,67 @@
+=======
+Strings
+=======
+
+A place for implementation of string algorithms
+
+Features
+--------
+
+* To see all the available functions in a module, you can just type ``help()`` with the module name as argument. For example,
+
+.. code:: python
+
+    >>> from pygorithm import strings
+    >>> help(strings)
+        Help on package pygorithm.strings in pygorithm:
+
+        NAME
+        pygorithm.strings - Collection of string methods and functions
+
+        PACKAGE CONTENTS
+        anagram
+        isogram
+        manacher_algorithm
+        palindrome
+        pangram
+
+
+Anagram
+-------
+
+* Functions and their uses
+
+.. automodule:: pygorithm.strings.anagram
+   :members:
+
+Isogram
+-------
+
+* Functions and their uses
+
+.. automodule:: pygorithm.strings.isogram
+   :members:
+
+Palindrome
+----------
+
+* Functions and their uses
+
+.. automodule:: pygorithm.strings.palindrome
+   :members:
+
+Pangram
+-------
+
+* Functions and their uses
+
+.. automodule:: pygorithm.strings.pangram
+   :members:
+
+Manacher's Algorithm
+--------------------
+
+* Functions and their uses
+
+.. automodule:: pygorithm.strings.manacher_algorithm
+   :members:

pygorithm/data_structures/linked_list.py

@@ -118,7 +118,7 @@ def delete(self, data):
                 # node not found
                 if temp is None:
                     return
-                
+
                 # TODO: local variable 'prev' might be referenced before assignment
                 # TODO: Fix this
                 prev.next = temp.next
@@ -214,3 +214,72 @@ def get_code():
         returns the code of the current class
         """
         return inspect.getsource(DoublyLinkedList)
+
+class CircularLinkedList(object):
+    '''
+    Class for circular linked list
+    '''
+    def __init__(self):
+        self.head = None
+        self.tail = None
+        self.size = 0
+
+    def clear(self):
+        ''' clears the head and tails of the linked list '''
+        self.tail = None
+        self.head = None
+
+    def get_data(self):
+        """
+        prints the elements in the linked list
+        """
+        l_list = []
+        current = self.tail
+        while True:
+            l_list.append(current.data)
+            current = current.next
+            if current == self.tail:
+                break
+        return l_list
+
+    def insert(self, data):
+        ''' inserts the data in to the linked list '''
+        node = Node(data)
+        if self.head:
+            self.head.next = node
+            self.head = node
+        else:
+            self.head = node
+            self.tail = node
+        self.head.next = self.tail
+        self.size += 1
+
+    def delete(self, data):
+        ''' deletes the specified element from linked list '''
+        current = self.tail
+        prev = self.tail
+        while prev == current or prev != self.head:
+            if current.data == data:
+                if current == self.tail:
+                    self.tail = current.next
+                    self.head.next = self.tail
+                else:
+                    prev.next = current.next
+                self.size -= 1
+                return
+            prev = current
+            current = current.next
+
+    @staticmethod
+    def get_code():
+        """
+        returns the code of the current class
+        """
+        return inspect.getsource(CircularLinkedList)
+
+if __name__ == '__main__':
+    cll = CircularLinkedList()
+    cll.insert(1)
+    cll.insert(2)
+    cll.insert(3)
+    print(cll.get_data())

pygorithm/dynamic_programming/binary_knapsack.py

@@ -3,11 +3,16 @@
 Created At: 25th August 2017
 """
 import inspect
-# TODO: Explain how this works / Explain what a knapsack is
 
 
 def knapsack(w, value, weight):
     """
+    The knapsack problem or rucksack problem is a problem in combinatorial optimization: Given a set of
+    items, each with a weight and a value, determine the number of each item to include in a collection
+    so that the total weight is less than or equal to a given limit and the total value is as large as
+    possible. It derives its name from the problem faced by someone who is constrained by a fixed-size
+    knapsack and must fill it with the most valuable items.
+
     :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

pygorithm/dynamic_programming/lis.py

@@ -8,9 +8,10 @@ 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:
+    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: an array of elements
+    :return: returns a tuple of maximum length of lis and an array of the elements of lis
     """
     # Initialize list with some value
     lis = [1] * len(_list)

pygorithm/greedy_algorithm/activity_selection.py

@@ -3,11 +3,16 @@
 Created On: 26th August 2017
 """
 import inspect
-# TODO: Explain what this is / how it works
 
 
 def activity_selection(start_times, finish_times):
     """
+    The activity selection problem is a combinatorial optimization problem concerning the selection of
+    non-conflicting activities to perform within a given time frame, given a set of activities each marked
+    by a start time (si) and finish time (fi). The problem is to select the maximum number of activities
+    that can be performed by a single person or machine, assuming that a person can only work on a single
+    activity at a time.
+
     :param start_times: An array that contains start time of all activities
     :param finish_times: An array that conatins finish time of all activities
     """

pygorithm/greedy_algorithm/fractional_knapsack.py

@@ -3,11 +3,16 @@
 Created On: 22nd August 2017
 """
 import inspect
-# TODO: Explain how this works / Explain what a knapsack is
 
 
 def knapsack(w, item_values, item_weights):
     """
+    The knapsack problem or rucksack problem is a problem in combinatorial optimization: Given a set of
+    items, each with a weight and a value, determine the number of each item to include in a collection so
+    that the total weight is less than or equal to a given limit and the total value is as large as
+    possible. It derives its name from the problem faced by someone who is constrained by a fixed-size
+    knapsack and must fill it with the most valuable items.
+
     :param w: maximum weight capacity
     :param item_values: a list of values of items in the knapsack
     :param item_weights: a list of weights of items in the knapsack